nextrush 1.5.0 → 2.0.0

package/dist/index.d.ts

@@ -1,889 +1,258 @@
-import { IncomingMessage, ServerResponse } from 'http';
-import { ParsedUrlQuery } from 'querystring';
-import { Socket } from 'net';
-import { Writable } from 'stream';
-
-type Dict<T = unknown> = Record<string, T>;
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { ParsedUrlQuery } from 'node:querystring';
+import { EventEmitter } from 'node:events';
 
 /**
- * HTTP-related type definitions
+ * Custom error classes for NextRush v2
+ *
+ * @packageDocumentation
  */
-
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'ALL';
-type ContentType = 'application/json' | 'application/x-www-form-urlencoded' | 'text/plain' | 'text/html' | 'multipart/form-data' | string;
-interface ParsedRequest extends IncomingMessage {
-    query: ParsedUrlQuery;
-    params: Dict<string>;
-    body: unknown;
-    pathname: string;
-    originalUrl: string;
-}
-interface ParsedResponse extends ServerResponse {
-    locals: Dict<unknown>;
-}
-interface RequestContext {
-    request: ParsedRequest;
-    response: ParsedResponse;
-    params: Dict<string>;
-    query: ParsedUrlQuery;
-    body: unknown;
-    startTime: number;
-}
-interface BodyParserOptions {
-    maxSize?: number;
-    timeout?: number;
-    allowedContentTypes?: ContentType[];
-    strict?: boolean;
-}
-
 /**
- * 🔥 Optimized Error Handler - Simple and Efficient
- * - Memory optimized with smart caching
- * - Performance-first design
- * - Enterprise-grade error classification
+ * Base error class for NextRush v2
  */
-
-interface ErrorHandlerConfig {
-    includeStack?: boolean;
-    logErrors?: boolean;
-    customErrorHandler?: (error: Error, context: RequestContext) => void;
-    enableMetrics?: boolean;
-    sanitizeProductionErrors?: boolean;
-}
-declare class ErrorHandler {
-    private config;
-    private errorCount;
-    private lastErrorTime;
-    constructor(config?: ErrorHandlerConfig);
-    /**
-     * Handle an error and send appropriate HTTP response
-     */
-    handle(error: Error, context: RequestContext): Promise<void>;
-    /**
-     * Convert any error to NextRushError with smart classification
-     */
-    private normalizeError;
-    /**
-     * Intelligent error classification
-     */
-    private classifyError;
-    /**
-     * Send formatted error response
-     */
-    private sendErrorResponse;
-    /**
-     * Smart error logging
-     */
-    private logError;
-    /**
-     * Utility methods
-     */
-    private shouldIncludeStack;
-    private extractCorrelationId;
-    private handleFallbackError;
+declare class NextRushError extends Error {
+    readonly statusCode: number;
+    readonly code: string;
+    readonly isOperational: boolean;
+    readonly timestamp: Date;
+    constructor(message: string, statusCode?: number, code?: string, isOperational?: boolean);
     /**
-     * Configure the error handler
+     * Create error from HTTP status code
      */
-    configure(config: Partial<ErrorHandlerConfig>): void;
+    static fromStatusCode(statusCode: number, message?: string): NextRushError;
     /**
-     * Get basic metrics
+     * Get error code from status code
      */
-    getMetrics(): {
-        totalErrors: number;
-        lastErrorTime: number;
-    };
+    private static getErrorCode;
     /**
-     * Reset metrics
+     * Convert error to JSON
      */
-    resetMetrics(): void;
+    toJSON(): Record<string, unknown>;
 }
-
 /**
- * Express-style request and response interfaces
- * Making NextRush familiar and easy to use
+ * Bad Request Error (400)
  */
-
-interface ValidationRule$1 {
-    required?: boolean;
-    type?: 'string' | 'number' | 'email' | 'url' | 'boolean';
-    minLength?: number;
-    maxLength?: number;
-    min?: number;
-    max?: number;
-    custom?: (value: any) => boolean;
-    message?: string;
-    sanitize?: SanitizeOptions;
-}
-interface ValidationResult$1 {
-    isValid: boolean;
-    errors: Record<string, string[]>;
-    sanitized: Record<string, any>;
-}
-interface SanitizeOptions {
-    trim?: boolean;
-    escape?: boolean;
-    lowercase?: boolean;
-    uppercase?: boolean;
-    removeHtml?: boolean;
-    removeSpecialChars?: boolean;
-}
-interface RateLimitInfo {
-    limit: number;
-    remaining: number;
-    reset: number;
-    retryAfter: number;
-}
-interface UserAgentInfo {
-    raw: string;
-    browser: string;
-    os: string;
-    device: string;
-    isBot: boolean;
-    isMobile: boolean;
-}
-interface RequestTiming {
-    start: number;
-    duration: number;
-    timestamp: string;
+declare class BadRequestError extends NextRushError {
+    constructor(message?: string);
 }
-interface NextRushRequest extends IncomingMessage {
-    params: Record<string, string>;
-    query: ParsedUrlQuery;
-    body: any;
-    pathname: string;
-    originalUrl: string;
-    path: string;
-    files: Record<string, any>;
-    cookies: Record<string, string>;
-    signedCookies?: Record<string, string>;
-    session: Record<string, any>;
-    locals: Record<string, any>;
-    startTime: number;
-    id?: string;
-    middlewareStack?: string[];
-    param(name: string): string | undefined;
-    header(name: string): string | undefined;
-    get(name: string): string | undefined;
-    ip(): string;
-    secure(): boolean;
-    protocol(): string;
-    hostname(): string;
-    fullUrl(): string;
-    is(type: string): boolean;
-    accepts(types: string | string[]): string | false;
-    fresh: boolean;
-    stale: boolean;
-    parseCookies(): Record<string, string>;
-    validate(rules: Record<string, ValidationRule$1>): ValidationResult$1;
-    sanitize(value: any, options?: SanitizeOptions): any;
-    sanitizeObject(obj: any, options?: any): any;
-    rateLimit(): RateLimitInfo;
-    fingerprint(): string;
-    userAgent(): UserAgentInfo;
-    timing(): RequestTiming;
-    getRequestTiming(): any;
-    isValidEmail(email: string): boolean;
-    isValidUrl(url: string): boolean;
-    sanitizeValue(value: any, rule: ValidationRule$1): any;
-    parseBrowser(ua: string): string;
-    parseOS(ua: string): string;
-    parseDevice(ua: string): string;
-    isBot(ua: string): boolean;
-    isMobile(ua: string): boolean;
+/**
+ * Unauthorized Error (401)
+ */
+declare class UnauthorizedError extends NextRushError {
+    constructor(message?: string);
 }
-interface NextRushResponse extends ServerResponse {
-    locals: Record<string, any>;
-    status(code: number): NextRushResponse;
-    json(data: any): void;
-    send(data: string | Buffer | object): void;
-    html(data: string): void;
-    text(data: string): void;
-    xml(data: string): void;
-    csv(data: any[], filename?: string): void;
-    stream(stream: NodeJS.ReadableStream, contentType?: string, options?: {
-        bufferSize?: number;
-        highWaterMark?: number;
-        enableCompression?: boolean;
-    }): void;
-    sendFile(filePath: string, options?: {
-        maxAge?: number;
-        lastModified?: boolean;
-        etag?: boolean;
-        dotfiles?: 'allow' | 'deny' | 'ignore';
-        root?: string;
-        headers?: Record<string, string>;
-        acceptRanges?: boolean;
-    }): void;
-    download(filePath: string, filename?: string, options?: any): void;
-    getSmartContentType(filePath: string): string;
-    generateETag(stats: any): string;
-    redirect(url: string, status?: number): void;
-    redirectPermanent(url: string): void;
-    redirectTemporary(url: string): void;
-    set(field: string, value: string): NextRushResponse;
-    set(fields: Record<string, string>): NextRushResponse;
-    header(field: string, value: string): NextRushResponse;
-    removeHeader(field: string): NextRushResponse;
-    get(field: string): string | undefined;
-    cookie(name: string, value: string, options?: {
-        maxAge?: number;
-        expires?: Date;
-        path?: string;
-        domain?: string;
-        secure?: boolean;
-        httpOnly?: boolean;
-        sameSite?: 'strict' | 'lax' | 'none';
-        signed?: boolean;
-    }): NextRushResponse;
-    clearCookie(name: string, options?: any): NextRushResponse;
-    render(template: string, data?: any): void;
-    getContentTypeFromExtension(ext: string): string;
-    getNestedValue(obj: any, path: string): any;
-    isTruthy(value: any): boolean;
-    cache(seconds: number): NextRushResponse;
-    noCache(): NextRushResponse;
-    cors(origin?: string): NextRushResponse;
-    security(): NextRushResponse;
-    compress(): NextRushResponse;
-    success(data: any, message?: string): void;
-    error(message: string, code?: number, details?: any): void;
-    paginate(data: any[], page: number, limit: number, total: number): void;
-    time(label?: string): NextRushResponse;
+/**
+ * Forbidden Error (403)
+ */
+declare class ForbiddenError extends NextRushError {
+    constructor(message?: string);
 }
-type ExpressHandler$1 = (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>;
-type ExpressMiddleware$1 = (req: NextRushRequest, res: NextRushResponse, next: () => void) => void | Promise<void>;
-
 /**
- * Routing-related type definitions
+ * Not Found Error (404)
  */
-
-type Path = string | RegExp;
-
-interface RouteHandler$1 {
-    (context: RequestContext): Promise<void> | void;
-}
-interface MiddlewareHandler$1 {
-    (context: RequestContext, next: () => Promise<void>): Promise<void> | void;
-}
-interface RouterOptions {
-    caseSensitive?: boolean;
-    strict?: boolean;
-    mergeParams?: boolean;
-    useOptimizedMatcher?: boolean;
-    enableCaching?: boolean;
-    cacheSize?: number;
-    enablePrefixOptimization?: boolean;
-    enableMetrics?: boolean;
+declare class NotFoundError extends NextRushError {
+    constructor(message?: string);
 }
-interface Route {
-    id: string;
-    path: Path;
-    method: HttpMethod;
-    handler: RouteHandler$1;
-    middleware?: MiddlewareHandler$1[];
-    metadata?: Record<string, any>;
+/**
+ * Method Not Allowed Error (405)
+ */
+declare class MethodNotAllowedError extends NextRushError {
+    constructor(message?: string);
 }
-
-declare class Router {
-    private routeManager;
-    private globalMiddleware;
-    private routerOptions;
-    constructor(options?: RouterOptions);
-    /**
-     * Add global middleware that runs for all routes
-     */
-    use(middleware: MiddlewareHandler$1 | ExpressMiddleware$1): this;
-    /**
-     * Register a GET route
-     */
-    get(path: Path, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    get(path: Path, handler: (context: RequestContext) => void | Promise<void>): this;
-    get(path: Path, middleware: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    get(path: Path, middleware: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    get(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    get(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    get(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    get(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    /**
-     * Register a POST route
-     */
-    post(path: Path, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    post(path: Path, handler: (context: RequestContext) => void | Promise<void>): this;
-    post(path: Path, middleware: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    post(path: Path, middleware: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    post(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    post(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    post(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    post(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    post(path: Path, middleware1: MiddlewareHandler$1 | ExpressMiddleware$1, middleware2: MiddlewareHandler$1 | ExpressMiddleware$1, middleware3: MiddlewareHandler$1 | ExpressMiddleware$1, handler: RouteHandler$1): this;
-    post(path: Path, middleware1: MiddlewareHandler$1 | ExpressMiddleware$1, middleware2: MiddlewareHandler$1 | ExpressMiddleware$1, middleware3: MiddlewareHandler$1 | ExpressMiddleware$1, handler: ExpressHandler$1): this;
-    /**
-     * Register a PUT route
-     */
-    put(path: Path, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    put(path: Path, handler: (context: RequestContext) => void | Promise<void>): this;
-    put(path: Path, middleware: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    put(path: Path, middleware: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    put(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    put(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    put(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    put(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    /**
-     * Register a DELETE route
-     */
-    delete(path: Path, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    delete(path: Path, handler: (context: RequestContext) => void | Promise<void>): this;
-    delete(path: Path, middleware: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    delete(path: Path, middleware: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    delete(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    delete(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    delete(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    delete(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    /**
-     * Register a PATCH route
-     */
-    patch(path: Path, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    patch(path: Path, handler: (context: RequestContext) => void | Promise<void>): this;
-    patch(path: Path, middleware: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    patch(path: Path, middleware: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    patch(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    patch(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    patch(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    patch(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    /**
-     * Register a HEAD route
-     */
-    head(path: Path, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    head(path: Path, handler: (context: RequestContext) => void | Promise<void>): this;
-    head(path: Path, middleware: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    head(path: Path, middleware: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    head(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    head(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    head(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    head(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    /**
-     * Register an OPTIONS route
-     */
-    options(path: Path, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    options(path: Path, handler: (context: RequestContext) => void | Promise<void>): this;
-    options(path: Path, middleware: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    options(path: Path, middleware: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    options(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    options(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    options(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>): this;
-    options(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: (context: RequestContext) => void | Promise<void>): this;
-    /**
-     * Handle incoming request
-     */
-    handle(context: RequestContext): Promise<void>;
-    /**
-     * Execute middleware chain and route handler
-     */
-    private executeMiddlewareChain;
-    /**
-     * Add a route with the specified method (internal)
-     */
-    private registerRoute;
-    /**
-     * Add a route to this router (public API for mounting)
-     */
-    addRoute(method: HttpMethod, path: Path, handler: RouteHandler$1 | ExpressHandler$1, middleware?: (MiddlewareHandler$1 | ExpressMiddleware$1)[]): this;
-    /**
-     * Internal method for Application class - allows spreading middleware
-     */
-    private _addRoute;
-    /**
-     * Internal GET method for Application class
-     */
-    _get(path: Path, handler: RouteHandler$1 | ExpressHandler$1, middleware?: (MiddlewareHandler$1 | ExpressMiddleware$1)[]): this;
-    /**
-     * Internal POST method for Application class
-     */
-    _post(path: Path, handler: RouteHandler$1 | ExpressHandler$1, middleware?: (MiddlewareHandler$1 | ExpressMiddleware$1)[]): this;
-    /**
-     * Internal PUT method for Application class
-     */
-    _put(path: Path, handler: RouteHandler$1 | ExpressHandler$1, middleware?: (MiddlewareHandler$1 | ExpressMiddleware$1)[]): this;
-    /**
-     * Internal DELETE method for Application class
-     */
-    _delete(path: Path, handler: RouteHandler$1 | ExpressHandler$1, middleware?: (MiddlewareHandler$1 | ExpressMiddleware$1)[]): this;
-    /**
-     * Internal PATCH method for Application class
-     */
-    _patch(path: Path, handler: RouteHandler$1 | ExpressHandler$1, middleware?: (MiddlewareHandler$1 | ExpressMiddleware$1)[]): this;
-    /**
-     * Internal HEAD method for Application class
-     */
-    _head(path: Path, handler: RouteHandler$1 | ExpressHandler$1, middleware?: (MiddlewareHandler$1 | ExpressMiddleware$1)[]): this;
-    /**
-     * Internal OPTIONS method for Application class
-     */
-    _options(path: Path, handler: RouteHandler$1 | ExpressHandler$1, middleware?: (MiddlewareHandler$1 | ExpressMiddleware$1)[]): this;
-    /**
-     * Get all registered routes
-     */
-    getRoutes(method?: HttpMethod): Route[];
-    /**
-     * Get router statistics
-     */
-    getStats(): {
-        globalMiddleware: number;
-        totalRoutes: number;
-        routesByMethod: Record<HttpMethod, number>;
-        methods: HttpMethod[];
-        performanceStats?: any;
-    };
-    /**
-     * Clear all routes and middleware
-     */
-    clear(): void;
-    /**
-     * Create a sub-router with merged options
-     */
-    createSubRouter(options?: Partial<RouterOptions>): Router;
-    /**
-     * Mount another router with a path prefix
-     */
-    mount(pathPrefix: string, router: Router): this;
-    private combinePaths;
-    /**
-     * Configure the router
-     */
-    configure(options: Partial<RouterOptions>): void;
-    /**
-     * Check if a handler is an Express-style handler
-     */
-    private isExpressHandler;
-    /**
-     * Convert Express-style handler to NextRush handler
-     */
-    private convertHandler;
-    /**
-     * Check if middleware is Express-style
-     */
-    private isExpressMiddleware;
-    /**
-     * Convert Express-style middleware to NextRush middleware
-     */
-    private convertMiddleware;
+/**
+ * Conflict Error (409)
+ */
+declare class ConflictError extends NextRushError {
+    constructor(message?: string);
 }
-
 /**
- * 🚀 NextRush Simple Event System
- * Lightweight event-driven architecture for request/response tracking
+ * Unprocessable Entity Error (422)
  */
-type EventCallback<T = any> = (data: T) => void | Promise<void>;
+declare class UnprocessableEntityError extends NextRushError {
+    constructor(message?: string);
+}
 /**
- * 🎯 Simple Event Emitter
+ * Too Many Requests Error (429)
  */
-declare class SimpleEventEmitter {
-    private events;
-    private maxListeners;
-    /**
-     * Add event listener
-     */
-    on<T = any>(event: string, callback: EventCallback<T>): this;
-    /**
-     * Add one-time event listener
-     */
-    once<T = any>(event: string, callback: EventCallback<T>): this;
-    /**
-     * Remove event listener
-     */
-    off<T = any>(event: string, callback: EventCallback<T>): this;
-    /**
-     * Remove all listeners for event or all events
-     */
-    removeAllListeners(event?: string): this;
-    /**
-     * Emit event
-     */
-    emit<T = any>(event: string, data?: T): boolean;
-    /**
-     * Get listener count for event
-     */
-    listenerCount(event: string): number;
-    /**
-     * Get all event names
-     */
-    eventNames(): string[];
-    /**
-     * Get listeners for event
-     */
-    listeners<T = any>(event: string): EventCallback<T>[];
+declare class TooManyRequestsError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Internal Server Error (500)
+ */
+declare class InternalServerError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Service Unavailable Error (503)
+ */
+declare class ServiceUnavailableError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Validation Error (400)
+ */
+declare class ValidationError extends NextRushError {
+    readonly field: string;
+    readonly value: unknown;
+    constructor(message: string, field?: string, value?: unknown, statusCode?: number);
     /**
-     * Set max listeners
+     * Create validation error for specific field
      */
-    setMaxListeners(max: number): this;
+    static forField(field: string, message: string, value?: unknown): ValidationError;
     /**
-     * Get max listeners
+     * Create validation error for multiple fields
      */
-    getMaxListeners(): number;
+    static forFields(errors: Array<{
+        field: string;
+        message: string;
+        value?: unknown;
+    }>): ValidationError;
 }
-
 /**
- * 🚀 NextRush WebSocket - Type Definitions
- * Zero-dependency WebSocket implementation using raw Node.js
- * RFC 6455 compliant with advanced room and event management
+ * Authentication Error (401)
  */
-
-/**
- * WebSocket connection states (RFC 6455)
- */
-declare enum WebSocketReadyState {
-    CONNECTING = 0,
-    OPEN = 1,
-    CLOSING = 2,
-    CLOSED = 3
+declare class AuthenticationError extends NextRushError {
+    constructor(message?: string);
 }
 /**
- * NextRush WebSocket Connection
- * Pure Node.js implementation with advanced features
+ * Authorization Error (403)
  */
-interface NextRushWebSocket {
-    id: string;
-    socket: Socket;
-    readyState: WebSocketReadyState;
-    protocol: string;
-    extensions: string[];
-    send(data: string | Buffer | object): void;
-    ping(data?: Buffer): void;
-    pong(data?: Buffer): void;
-    close(code?: number, reason?: string): void;
-    broadcast(data: string | Buffer | object, room?: string): void;
-    join(room: string): Promise<void>;
-    leave(room: string): Promise<void>;
-    to(room: string): RoomEmitter;
-    emit(event: string, ...args: any[]): void;
-    on(event: string, handler: (...args: any[]) => void): void;
-    off(event: string, handler?: (...args: any[]) => void): void;
-    once(event: string, handler: (...args: any[]) => void): void;
-    ip: string;
-    userAgent: string;
-    origin: string;
-    rooms: Set<string>;
-    isAlive: boolean;
-    lastPing: number;
-    metadata: Record<string, any>;
-    connectedAt: Date;
-    lastActivity: Date;
+declare class AuthorizationError extends NextRushError {
+    constructor(message?: string);
 }
 /**
- * Room-based messaging interface
+ * Database Error (500)
  */
-interface RoomEmitter {
-    emit(event: string, ...args: any[]): void;
-    send(data: string | Buffer | object): void;
-    broadcast(data: string | Buffer | object): void;
-    except(socketId: string): RoomEmitter;
-    to(room: string): RoomEmitter;
+declare class DatabaseError extends NextRushError {
+    readonly operation: string;
+    readonly table: string | undefined;
+    constructor(message: string, operation?: string, table?: string, statusCode?: number);
 }
 /**
- * WebSocket event handlers
+ * Network Error (502)
  */
-type WebSocketHandler = (socket: NextRushWebSocket, req: NextRushRequest) => void | Promise<void>;
-
+declare class NetworkError extends NextRushError {
+    readonly host: string;
+    readonly port: number;
+    constructor(message: string, host: string, port: number);
+}
 /**
- * Core interfaces for NextRush framework
- * Based on old codebase patterns but modernized for new architecture
+ * Timeout Error (408)
  */
-
-type RouteHandler = (context: RequestContext) => void | Promise<void>;
-type ExpressHandler = (req: NextRushRequest, res: NextRushResponse) => void | Promise<void>;
-type MiddlewareHandler = (context: RequestContext, next: () => void) => void | Promise<void>;
-type ExpressMiddleware = (req: NextRushRequest, res: NextRushResponse, next: () => void) => void | Promise<void>;
-/**
- * Minimal Application interface - defines core methods that components need
- */
-interface MinimalApplication$1 {
-    get(path: Path, handler: ExpressHandler): MinimalApplication$1;
-    get(path: Path, handler: RouteHandler): MinimalApplication$1;
-    get(path: Path, middleware: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    get(path: Path, middleware: MiddlewareHandler, handler: RouteHandler): MinimalApplication$1;
-    get(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    get(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, middleware3: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    get(path: Path, ...args: (RouteHandler | ExpressHandler | MiddlewareHandler | ExpressMiddleware)[]): MinimalApplication$1;
-    post(path: Path, handler: ExpressHandler): MinimalApplication$1;
-    post(path: Path, handler: RouteHandler): MinimalApplication$1;
-    post(path: Path, middleware: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    post(path: Path, middleware: MiddlewareHandler, handler: RouteHandler): MinimalApplication$1;
-    post(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    post(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, middleware3: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    post(path: Path, ...args: (RouteHandler | ExpressHandler | MiddlewareHandler | ExpressMiddleware)[]): MinimalApplication$1;
-    put(path: Path, handler: ExpressHandler): MinimalApplication$1;
-    put(path: Path, handler: RouteHandler): MinimalApplication$1;
-    put(path: Path, middleware: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    put(path: Path, middleware: MiddlewareHandler, handler: RouteHandler): MinimalApplication$1;
-    put(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    put(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, middleware3: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    put(path: Path, ...args: (RouteHandler | ExpressHandler | MiddlewareHandler | ExpressMiddleware)[]): MinimalApplication$1;
-    delete(path: Path, handler: ExpressHandler): MinimalApplication$1;
-    delete(path: Path, handler: RouteHandler): MinimalApplication$1;
-    delete(path: Path, middleware: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    delete(path: Path, middleware: MiddlewareHandler, handler: RouteHandler): MinimalApplication$1;
-    delete(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    delete(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, middleware3: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    delete(path: Path, ...args: (RouteHandler | ExpressHandler | MiddlewareHandler | ExpressMiddleware)[]): MinimalApplication$1;
-    patch(path: Path, handler: ExpressHandler): MinimalApplication$1;
-    patch(path: Path, handler: RouteHandler): MinimalApplication$1;
-    patch(path: Path, middleware: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    patch(path: Path, middleware: MiddlewareHandler, handler: RouteHandler): MinimalApplication$1;
-    patch(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    patch(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, middleware3: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    patch(path: Path, ...args: (RouteHandler | ExpressHandler | MiddlewareHandler | ExpressMiddleware)[]): MinimalApplication$1;
-    head(path: Path, handler: ExpressHandler): MinimalApplication$1;
-    head(path: Path, handler: RouteHandler): MinimalApplication$1;
-    head(path: Path, middleware: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    head(path: Path, middleware: MiddlewareHandler, handler: RouteHandler): MinimalApplication$1;
-    head(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    head(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, middleware3: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    head(path: Path, ...args: (RouteHandler | ExpressHandler | MiddlewareHandler | ExpressMiddleware)[]): MinimalApplication$1;
-    options(path: Path, handler: ExpressHandler): MinimalApplication$1;
-    options(path: Path, handler: RouteHandler): MinimalApplication$1;
-    options(path: Path, middleware: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    options(path: Path, middleware: MiddlewareHandler, handler: RouteHandler): MinimalApplication$1;
-    options(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    options(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, middleware3: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    options(path: Path, ...args: (RouteHandler | ExpressHandler | MiddlewareHandler | ExpressMiddleware)[]): MinimalApplication$1;
-    all(path: Path, handler: ExpressHandler): MinimalApplication$1;
-    all(path: Path, handler: RouteHandler): MinimalApplication$1;
-    all(path: Path, middleware: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    all(path: Path, middleware: MiddlewareHandler, handler: RouteHandler): MinimalApplication$1;
-    all(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    all(path: Path, middleware1: ExpressMiddleware, middleware2: ExpressMiddleware, middleware3: ExpressMiddleware, handler: ExpressHandler): MinimalApplication$1;
-    all(path: Path, ...args: (RouteHandler | ExpressHandler | MiddlewareHandler | ExpressMiddleware)[]): MinimalApplication$1;
-    use(...args: any[]): MinimalApplication$1;
-    static(path: string, root?: string): MinimalApplication$1;
-    setViews: (path: string) => MinimalApplication$1;
-    render: (...args: any[]) => MinimalApplication$1;
-    ws: (path: string, handler: WebSocketHandler) => MinimalApplication$1;
-    listen(port: number | string, hostname?: string | (() => void), callback?: () => void): MinimalApplication$1;
-    close: (callback?: () => void) => MinimalApplication$1;
-}
-/**
- * Component lifecycle interface
- */
-interface Lifecycle$1 {
-    /**
-     * Called when component is installed into application
-     */
-    install?(app: MinimalApplication$1): void | Promise<void>;
-    /**
-     * Called when component is uninstalled from application
-     */
-    uninstall?(app: MinimalApplication$1): void | Promise<void>;
-    /**
-     * Called when application starts
-     */
-    start?(): void | Promise<void>;
-    /**
-     * Called when application stops
-     */
-    stop?(): void | Promise<void>;
+declare class TimeoutError extends NextRushError {
+    constructor(message?: string);
 }
-
 /**
- * Abstract base class for components
- * Provides a foundation for extensible components with inheritance
- *
- * @abstract
- * @example
- * ```typescript
- * class RouterComponent extends BaseComponent {
- *   constructor() {
- *     super('Router');
- *   }
- *
- *   public install(app: MinimalApplication): void {
- *     app.get = this.get.bind(this);
- *     app.post = this.post.bind(this);
- *   }
- * }
- * ```
+ * Rate Limit Error (429)
  */
-
+declare class RateLimitError extends NextRushError {
+    readonly retryAfter: number;
+    constructor(message?: string, retryAfter?: number);
+}
 /**
- * Abstract base class for all components
- * Enables OOP with inheritance for extensible component behavior
+ * Error Factory for creating common errors
  */
-declare abstract class BaseComponent implements Lifecycle$1 {
-    /**
-     * Unique component name
-     * @readonly
-     */
-    readonly name: string;
-    /**
-     * Component initialization status
-     * @protected
-     */
-    protected isInitialized: boolean;
-    /**
-     * Component running status
-     * @protected
-     */
-    protected isRunning: boolean;
+declare class ErrorFactory {
     /**
-     * Reference to the application instance
-     * @protected
+     * Create validation error
      */
-    protected app?: MinimalApplication$1;
+    static validation(field: string, message: string, value?: unknown): ValidationError;
     /**
-     * Create a new base component
-     * @param name - Unique component name
+     * Create not found error
      */
-    constructor(name: string);
+    static notFound(resource: string): NotFoundError;
     /**
-     * Install component on application (abstract - must be implemented)
-     * @param app - Minimal application instance
-     * @abstract
+     * Create unauthorized error
      */
-    abstract install(app: MinimalApplication$1): void | Promise<void>;
+    static unauthorized(message?: string): AuthenticationError;
     /**
-     * Start component (optional override)
-     * Called when application starts
+     * Create forbidden error
      */
-    start(): Promise<void>;
+    static forbidden(message?: string): AuthorizationError;
     /**
-     * Stop component (optional override)
-     * Called when application stops
+     * Create bad request error
      */
-    stop(): Promise<void>;
+    static badRequest(message?: string): BadRequestError;
     /**
-     * Check if component is initialized
-     * @returns True if component is initialized
+     * Create conflict error
      */
-    getIsInitialized(): boolean;
+    static conflict(message?: string): ConflictError;
     /**
-     * Check if component is running
-     * @returns True if component is running
+     * Create internal server error
      */
-    getIsRunning(): boolean;
+    static internal(message?: string): InternalServerError;
     /**
-     * Get component information
-     * @returns Component information object
+     * Create rate limit error
      */
-    getInfo(): ComponentInfo;
+    static rateLimit(message?: string, retryAfter?: number): RateLimitError;
     /**
-     * Set application reference (called during installation)
-     * @param app - Application instance
-     * @protected
+     * Create timeout error
      */
-    protected setApp(app: MinimalApplication$1): void;
+    static timeout(message?: string): TimeoutError;
     /**
-     * Ensure component is initialized
-     * @throws Error if component is not initialized
-     * @protected
+     * Create service unavailable error
      */
-    protected ensureInitialized(): void;
+    static serviceUnavailable(message?: string): ServiceUnavailableError;
     /**
-     * Ensure component is running
-     * @throws Error if component is not running
-     * @protected
+     * Create database error
      */
-    protected ensureRunning(): void;
+    static database(message: string, operation: string, table?: string): DatabaseError;
     /**
-     * Log component message with name prefix
-     * @param level - Log level
-     * @param message - Log message
-     * @param meta - Optional metadata
-     * @protected
+     * Create network error
      */
-    protected log(level: 'info' | 'warn' | 'error', message: string, meta?: any): void;
+    static network(message: string, host: string, port: number): NetworkError;
 }
 /**
- * Component information interface
+ * Exception Filter Interface (NestJS style)
  */
-interface ComponentInfo {
-    name: string;
-    isInitialized: boolean;
-    isRunning: boolean;
-    type: 'component' | 'plugin';
+interface ExceptionFilter {
+    catch(error: Error, ctx: any): void | Promise<void>;
 }
-
 /**
- * 🔌 BasePlugin - Core Plugin Implementation
- *
- * According to copilot instructions, all features must be implemented as plugins
- * inheriting from BasePlugin under src/plugins/
+ * Global Exception Filter
  */
-
+declare class GlobalExceptionFilter implements ExceptionFilter {
+    catch(error: Error, ctx: any): Promise<void>;
+}
 /**
- * Plugin Registry interface for event system and plugin access
+ * Exception Filter for specific error types
  */
-interface PluginRegistry {
-    emit(event: string, ...args: any[]): void;
-    on(event: string, listener: (...args: any[]) => void): void;
-    off(event: string, listener: (...args: any[]) => void): void;
-    getPlugin?(name: string): BasePlugin | undefined;
+declare class ValidationExceptionFilter implements ExceptionFilter {
+    catch(error: Error, ctx: any): Promise<void>;
 }
 /**
- * Base Plugin class that all NextRush plugins must inherit from
- * Follows the copilot instructions for unified plugin architecture
+ * Exception Filter for authentication errors
  */
-declare abstract class BasePlugin {
-    abstract name: string;
-    protected registry: PluginRegistry;
-    constructor(registry: PluginRegistry);
-    /**
-     * Install the plugin into the application
-     * This is where plugins register their capabilities (app.get, app.use, etc.)
-     */
-    abstract install(app: Application): void;
-    /**
-     * Start the plugin - activate its functionality
-     */
-    abstract start(): void;
-    /**
-     * Stop the plugin - deactivate its functionality
-     */
-    abstract stop(): void;
-    /**
-     * Emit events to other plugins
-     */
-    protected emit(event: string, ...args: any[]): void;
-    /**
-     * Listen to events from other plugins
-     */
-    protected on(event: string, listener: (...args: any[]) => void): void;
-    /**
-     * Remove event listener
-     */
-    protected off(event: string, listener: (...args: any[]) => void): void;
+declare class AuthenticationExceptionFilter implements ExceptionFilter {
+    catch(error: Error, ctx: any): Promise<void>;
 }
-
 /**
- * 🚀 MEGA ULTIMATE PARSER - NextRush Framework
- *
- * SINGLE UNIFIED PARSER WITH NODEJS RAW POWER + V8 ENGINE OPTIMIZATION
- *
- * Features:
- * - 🔥 Zero-copy buffer operations using Node.js raw power
- * - 🚀 V8 engine optimizations for maximum performance
- * - 🧠 AI-like content type auto-detection
- * - 🌊 Streaming parser with backpressure handling
- * - 💾 Memory-pooled buffer management
- * - ⚡ CPU-optimized parsing with vectorized operations
- * - 🎯 Smart caching and pre-compiled patterns
- * - 🛡️ Enterprise-grade error handling
- * - 📊 Real-time performance metrics collection
- *
- * This replaces ALL existing parsers with a single unified solution.
- *
- * @author NextRush Framework Team
- * @version 2.0.0 - MEGA ULTIMATE EDITION
- * @since 1.0.0
+ * Exception Filter for authorization errors
+ */
+declare class AuthorizationExceptionFilter implements ExceptionFilter {
+    catch(error: Error, ctx: any): Promise<void>;
+}
+/**
+ * Exception Filter for not found errors
  */
+declare class NotFoundExceptionFilter implements ExceptionFilter {
+    catch(error: Error, ctx: any): Promise<void>;
+}
+/**
+ * Exception Filter for rate limit errors
+ */
+declare class RateLimitExceptionFilter implements ExceptionFilter {
+    catch(error: Error, ctx: any): Promise<void>;
+}
 
 /**
- * 🔧 Ultimate parser configuration with enterprise-grade settings
- *
- * @interface MegaUltimateParserOptions
+ * 🔧 Enhanced parser configuration with enterprise-grade settings
  */
-interface MegaUltimateParserOptions {
+interface EnhancedBodyParserOptions {
     /** Maximum body size in bytes (default: 10MB) */
     maxSize?: number;
-    /** Request timeout in milliseconds (default: 30s) */
+    /** Request timeout in milliseconds (default: 5s) */
     timeout?: number;
     /** Enable streaming for large payloads (default: true) */
     enableStreaming?: boolean;
@@ -897,1975 +266,2051 @@ interface MegaUltimateParserOptions {
     autoDetectContentType?: boolean;
     /** Strict content type checking (default: false) */
     strictContentType?: boolean;
-    /** Enable debug logging (default: false) */
-    debug?: boolean;
-    /** Maximum number of files for multipart (default: 10) */
-    maxFiles?: number;
-    /** Maximum file size for uploads (default: 5MB) */
-    maxFileSize?: number;
-    /** Memory storage for files (default: true) */
-    memoryStorage?: boolean;
-    /** Upload directory for disk storage */
-    uploadDir?: string;
-    /** Character encoding (default: 'utf8') */
+    /** Enable metrics collection (default: true) */
+    enableMetrics?: boolean;
+    /** Encoding for text-based content (default: 'utf8') */
     encoding?: BufferEncoding;
+    /** Custom error messages */
+    errorMessages?: {
+        maxSizeExceeded?: string;
+        timeoutError?: string;
+        invalidContentType?: string;
+        parseError?: string;
+    };
 }
+
 /**
- * 📊 Performance metrics for monitoring
+ * Middleware Types for NextRush v2
  *
- * @interface MegaParserMetrics
+ * @packageDocumentation
  */
-interface MegaParserMetrics {
-    /** Total requests processed */
-    totalRequests: number;
-    /** Total parsing time in milliseconds */
-    totalParseTime: number;
-    /** Average parsing time per request */
-    averageParseTime: number;
-    /** Peak memory usage in bytes */
-    peakMemoryUsage: number;
-    /** Cache hit ratio (0-1) */
-    cacheHitRatio: number;
-    /** Parse success rate (0-1) */
-    successRate: number;
-    /** Total bytes processed */
-    totalBytesProcessed: number;
-}
 
 /**
- * 🚀 Body Parser Plugin v2.0 - MEGA ULTIMATE EDITION
- *
- * SINGLE UNIFIED PARSER THAT REPLACES ALL OTHER PARSERS
- *
- * Features:
- * - 🔥 Node.js raw power + V8 optimizations
- * - 🧠 Smart auto-detection
- * - ⚡ Zero-copy operations
- * - 📊 Performance monitoring
- * - 🛡️ Enterprise-grade error handling
- *
- * This plugin replaces:
- * - All http/parsers/* files
- * - All old body parser implementations
- * - Enhanced request parsing conflicts
- *
- * @author NextRush Framework Team
- * @version 2.0.0 - MEGA ULTIMATE EDITION
+ * Standard middleware function signature
  */
+type Middleware$1 = (ctx: Context, next: () => Promise<void>) => Promise<void>;
+/**
+ * CORS middleware options
+ */
+interface CorsOptions {
+    /** Allowed origins */
+    origin?: string | string[] | boolean | ((origin: string) => boolean);
+    /** Allowed methods */
+    methods?: string[];
+    /** Allowed headers */
+    allowedHeaders?: string[];
+    /** Exposed headers */
+    exposedHeaders?: string[];
+    /** Allow credentials */
+    credentials?: boolean;
+    /** Max age for preflight */
+    maxAge?: number;
+    /** Preflight continue */
+    preflightContinue?: boolean;
+    /** Options success status */
+    optionsSuccessStatus?: number;
+}
+/**
+ * Helmet middleware options
+ */
+interface HelmetOptions {
+    /** Content Security Policy */
+    contentSecurityPolicy?: {
+        directives: Record<string, string[]>;
+        reportOnly?: boolean;
+    };
+    /** HTTP Strict Transport Security */
+    hsts?: {
+        maxAge: number;
+        includeSubDomains?: boolean;
+        preload?: boolean;
+    };
+    /** XSS Protection */
+    xssFilter?: boolean;
+    /** Content Type Options */
+    noSniff?: boolean;
+    /** Frame Options */
+    frameguard?: {
+        action: 'DENY' | 'SAMEORIGIN' | 'ALLOW-FROM';
+        domain?: string;
+    };
+    /** Referrer Policy */
+    referrerPolicy?: {
+        policy: string;
+    };
+    /** Hide X-Powered-By header */
+    hidePoweredBy?: boolean;
+    /** DNS Prefetch Control */
+    dnsPrefetchControl?: {
+        allow?: boolean;
+    };
+    /** IE No Open */
+    ieNoOpen?: boolean;
+    /** Permitted Cross Domain Policies */
+    permittedCrossDomainPolicies?: {
+        permittedPolicies?: string;
+    };
+}
+/**
+ * Rate limiter options
+ */
+interface RateLimiterOptions {
+    /** Time window in milliseconds */
+    windowMs?: number;
+    /** Maximum requests per window */
+    max?: number;
+    /** Rate limit message */
+    message?: string;
+    /** Status code for rate limited requests */
+    statusCode?: number;
+    /** Include headers */
+    headers?: boolean;
+    /** Skip successful requests */
+    skipSuccessfulRequests?: boolean;
+    /** Skip failed requests */
+    skipFailedRequests?: boolean;
+    /** Key generator function */
+    keyGenerator?: (ctx: Context) => string;
+    /** Skip function */
+    skip?: (ctx: Context) => boolean;
+    /** Custom handler */
+    handler?: (ctx: Context) => void;
+    /** Store implementation */
+    store?: {
+        get(key: string): {
+            count: number;
+            resetTime: number;
+        } | null;
+        increment(key: string): {
+            count: number;
+            resetTime: number;
+        };
+        reset(key: string): void;
+        clear(): void;
+    };
+}
+/**
+ * Logger middleware options
+ */
+interface LoggerOptions {
+    /** Log format */
+    format?: 'simple' | 'detailed' | 'json' | 'combined';
+    /** Log level */
+    level?: 'error' | 'warn' | 'info' | 'http' | 'verbose' | 'debug' | 'silly';
+    /** Colorize output */
+    colorize?: boolean;
+    /** Include timestamp */
+    timestamp?: boolean;
+    /** Show headers */
+    showHeaders?: boolean;
+    /** Show body */
+    showBody?: boolean;
+    /** Show query */
+    showQuery?: boolean;
+    /** Show response time */
+    showResponseTime?: boolean;
+    /** Show user agent */
+    showUserAgent?: boolean;
+    /** Show referer */
+    showReferer?: boolean;
+    /** Show IP */
+    showIP?: boolean;
+    /** Show method */
+    showMethod?: boolean;
+    /** Show URL */
+    showURL?: boolean;
+    /** Show status */
+    showStatus?: boolean;
+    /** Show response size */
+    showResponseSize?: boolean;
+    /** Custom format function */
+    customFormat?: (ctx: Context, duration: number) => string;
+    /** Filter function */
+    filter?: (ctx: Context) => boolean;
+    /** Output stream */
+    stream?: NodeJS.WritableStream;
+}
+/**
+ * Compression middleware options
+ */
+interface CompressionOptions {
+    /** Compression level (1-9) */
+    level?: number;
+    /** Minimum size to compress */
+    threshold?: number;
+    /** Filter function */
+    filter?: (ctx: Context) => boolean;
+    /** Content types to compress */
+    contentType?: string[];
+    /** Content types to exclude */
+    exclude?: string[];
+    /** Enable gzip */
+    gzip?: boolean;
+    /** Enable deflate */
+    deflate?: boolean;
+    /** Enable brotli */
+    brotli?: boolean;
+    /** Window size */
+    windowBits?: number;
+    /** Memory level */
+    memLevel?: number;
+    /** Strategy */
+    strategy?: number;
+    /** Chunk size */
+    chunkSize?: number;
+    /** Dictionary */
+    dictionary?: Buffer;
+    /** Enable adaptive compression based on CPU usage */
+    adaptive?: boolean;
+    /** Maximum CPU usage threshold for adaptive compression (percentage) */
+    maxCpuUsage?: number;
+    /** Backpressure threshold for skipping compression */
+    backpressureThreshold?: number;
+}
+/**
+ * Request ID middleware options
+ */
+interface RequestIdOptions {
+    /** Request ID header name */
+    headerName?: string;
+    /** Request ID generator function */
+    generator?: () => string;
+    /** Add to response headers */
+    addResponseHeader?: boolean;
+    /** Echo existing header */
+    echoHeader?: boolean;
+    /** Set in context */
+    setInContext?: boolean;
+    /** Include in logs */
+    includeInLogs?: boolean;
+}
+/**
+ * Timer middleware options
+ */
+interface TimerOptions {
+    /** Response time header name */
+    header?: string;
+    /** Number of decimal places */
+    digits?: number;
+    /** Time unit suffix */
+    suffix?: string;
+    /** Include start time */
+    includeStartTime?: boolean;
+    /** Include end time */
+    includeEndTime?: boolean;
+    /** Include duration */
+    includeDuration?: boolean;
+    /** Format type */
+    format?: 'milliseconds' | 'seconds' | 'microseconds' | 'nanoseconds';
+    /** Threshold for logging */
+    threshold?: number;
+    /** Log slow requests */
+    logSlow?: boolean;
+    /** Slow request threshold */
+    logSlowThreshold?: number;
+    /** Custom format function */
+    customFormat?: (duration: number) => string;
+}
 
 /**
- * 🚀 MEGA ULTIMATE Body Parser Plugin
- *
- * The single, unified body parser that handles ALL request body parsing
- * with maximum performance and zero conflicts.
- *
- * @class BodyParserPlugin
- * @extends BasePlugin
+ * Cookie options interface with security defaults
  */
-declare class BodyParserPlugin extends BasePlugin {
-    name: string;
-    /** The mega ultimate parser instance */
-    private megaParser;
-    /** Plugin options merged from application config */
-    private options;
-    /** Debug logging flag */
-    private debug;
-    /**
-     * Initialize the mega ultimate body parser plugin
-     *
-     * @param registry - Plugin registry for event communication
-     */
-    constructor(registry: any);
-    /**
-     * 🔌 Install the body parser plugin
-     *
-     * @param app - Application instance
-     */
-    install(app: Application): void;
-    /**
-     * 🚀 Start the body parser plugin
-     */
-    start(): void;
-    /**
-     * 🛑 Stop the body parser plugin and cleanup resources
-     */
-    stop(): void;
-    /**
-     * 🔧 Install the ultimate auto body parser middleware
-     *
-     * This replaces ALL existing body parsing logic with a single unified solution
-     *
-     * @param app - Application instance
-     */
-    private installAutoBodyParser;
-    /**
-     * 🎯 Set request body with FIXED property descriptor
-     *
-     * This fixes the middleware chain issue where req.body becomes undefined
-     *
-     * @param req - Request object
-     * @param body - Parsed body data
-     */
-    private setRequestBody;
-    /**
-     * 📊 Get performance metrics from the mega parser
-     *
-     * @returns MegaParserMetrics - Performance metrics
-     */
-    getMetrics(): MegaParserMetrics;
-    /**
-     * 🔧 Update parser options at runtime
-     *
-     * @param newOptions - New parser options
-     */
-    updateOptions(newOptions: Partial<MegaUltimateParserOptions>): void;
-    /**
-     * 🧹 Manual cleanup method for removing debug logs
-     */
-    static removeDebugLogs(): void;
+interface CookieOptions {
+    /** Domain for the cookie */
+    domain?: string;
+    /** Expiration date */
+    expires?: Date;
+    /** HTTP Only flag (default: true for security) */
+    httpOnly?: boolean;
+    /** Max age in seconds */
+    maxAge?: number;
+    /** Path (default: '/') */
+    path?: string;
+    /** Priority (Low, Medium, High) */
+    priority?: 'Low' | 'Medium' | 'High';
+    /** SameSite attribute (default: 'Strict') */
+    sameSite?: 'Strict' | 'Lax' | 'None' | boolean;
+    /** Secure flag (default: true in production) */
+    secure?: boolean;
 }
 
 /**
- * 🎨 Middleware Composition Functions - NextRush Framework
+ * Application configuration options
+ */
+interface ApplicationOptions {
+    /** Port to listen on (default: 3000) */
+    port?: number;
+    /** Host to bind to (default: 'localhost') */
+    host?: string;
+    /** Enable debug mode */
+    debug?: boolean;
+    /** Trust proxy headers */
+    trustProxy?: boolean;
+    /** Maximum request body size in bytes */
+    maxBodySize?: number;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Enable CORS by default */
+    cors?: boolean;
+    /** Static files directory */
+    static?: string;
+    /** Template engine configuration */
+    template?: {
+        engine: string;
+        directory: string;
+    };
+    /** HTTP keep-alive timeout in milliseconds */
+    keepAlive?: number;
+}
+/**
+ * Enhanced request object
+ */
+interface NextRushRequest extends IncomingMessage {
+    /** Request body */
+    body?: unknown;
+    /** Route parameters */
+    params: Record<string, string>;
+    /** Query parameters */
+    query: ParsedUrlQuery;
+    /** Request path */
+    path: string;
+    /** Client IP address */
+    ip: string;
+    /** Request protocol */
+    protocol: string;
+    /** Whether the request is secure */
+    secure: boolean;
+    /** Original request URL */
+    originalUrl: string;
+}
+/**
+ * Enhanced response object
+ */
+interface NextRushResponse$1 extends ServerResponse {
+    /** Set response status code */
+    status(code: number): NextRushResponse$1;
+    /** Send JSON response (fast by default) */
+    json(data: unknown): NextRushResponse$1;
+    /** Send HTML response */
+    html(data: string): NextRushResponse$1;
+    /** Send text response */
+    text(data: string): NextRushResponse$1;
+    /** Send CSV response */
+    csv(data: string): NextRushResponse$1;
+    /** Send XML response */
+    xml(data: string): NextRushResponse$1;
+    /** Send file response */
+    file(path: string, options?: {
+        root?: string;
+    }): NextRushResponse$1;
+    /** Send file response (alias) */
+    sendFile(path: string, options?: {
+        root?: string;
+        etag?: boolean;
+    }): NextRushResponse$1;
+    /** Send download response */
+    download(path: string, filename?: string): NextRushResponse$1;
+    /** Redirect response */
+    redirect(url: string, status?: number): NextRushResponse$1;
+    /** Set response header */
+    set(name: string, value: string | number | string[]): NextRushResponse$1;
+    /** Get response header */
+    get(name: string): string | number | string[] | undefined;
+    /** Remove response header */
+    remove(name: string): NextRushResponse$1;
+    /** Set response type */
+    type(type: string): NextRushResponse$1;
+    /** Set response length */
+    length(length: number): NextRushResponse$1;
+    /** Set response etag */
+    etag(etag: string): NextRushResponse$1;
+    /** Set response last modified */
+    lastModified(date: Date): NextRushResponse$1;
+}
+
+/**
+ * Koa-style context types for NextRush v2
  *
- * Provides Express-like middleware composition functions:
- * - compose() - Combine multiple middleware
- * - when() - Conditional middleware
- * - unless() - Exclusion middleware
- * - named() - Debug middleware with names
+ * @packageDocumentation
  */
 
 /**
- * Compose multiple middleware into a single middleware function
- * Optimized for performance with minimal function calls
- *
- * @example
- * const authFlow = compose(checkApiKey, checkUser, rateLimit);
- * app.get('/protected', authFlow, handler);
+ * WebSocket connection interface
  */
-declare function compose(...middlewares: ExpressMiddleware$1[]): ExpressMiddleware$1;
+interface WSConnection {
+    /** Unique connection ID */
+    id: string;
+    /** WebSocket request URL */
+    url: string;
+    /** Connection alive status */
+    isAlive: boolean;
+    /** Last pong timestamp */
+    lastPong: number;
+    /** Send message to client */
+    send(data: string | Buffer): void;
+    /** Close connection */
+    close(code?: number, reason?: string): void;
+    /** Join a room */
+    join(room: string): void;
+    /** Leave a room */
+    leave(room: string): void;
+    /** Listen for incoming messages */
+    onMessage(listener: (data: string | Buffer) => void): void;
+    /** Listen for connection close */
+    onClose(listener: (code: number, reason: string) => void): void;
+}
+/**
+ * WebSocket route handler type
+ */
+type WSHandler = (socket: WSConnection, req: IncomingMessage) => void | Promise<void>;
+/**
+ * WebSocket middleware type
+ */
+type WSMiddleware = (socket: WSConnection, req: IncomingMessage, next: () => void) => void | Promise<void>;
+/**
+ * WebSocket plugin options
+ */
+interface WebSocketPluginOptions {
+    /** Accepted paths (exact or wildcard *) */
+    path?: string | string[];
+    /** Ping interval in milliseconds */
+    heartbeatMs?: number;
+    /** Close if no pong within this timeout */
+    pongTimeoutMs?: number;
+    /** Maximum concurrent connections */
+    maxConnections?: number;
+    /** Maximum message size in bytes */
+    maxMessageSize?: number;
+    /** Allowed origins for CORS */
+    allowOrigins?: (string | RegExp)[];
+    /** Custom client verification */
+    verifyClient?: (req: IncomingMessage) => Promise<boolean> | boolean;
+    /** Debug mode */
+    debug?: boolean;
+}
 /**
- * Conditionally apply middleware based on a condition function
- *
- * @example
- * const mobileOnly = when(
- *   (req) => req.headers['user-agent']?.includes('Mobile'),
- *   mobileOptimization
- * );
+ * Enhanced response object with Express-like methods
  */
-declare function when(condition: (req: NextRushRequest) => boolean, middleware: ExpressMiddleware$1): ExpressMiddleware$1;
+interface NextRushResponse extends ServerResponse {
+    /** Send JSON response */
+    json(data: unknown): NextRushResponse;
+    /** Send HTML response */
+    html(data: string): NextRushResponse;
+    /** Send text response */
+    text(data: string): NextRushResponse;
+    /** Send CSV response */
+    csv(data: string): NextRushResponse;
+    /** Send XML response */
+    xml(data: string): NextRushResponse;
+    /** Send any data type response */
+    send(data: string | Buffer | object): void;
+    /** Stream response */
+    stream(stream: NodeJS.ReadableStream, contentType?: string): void;
+    /** Render HTML from a template string or a template name under viewsDir */
+    render(templateOrName: string, data?: Record<string, unknown>, options?: {
+        layout?: string;
+    }): Promise<void>;
+    /** Send file response (alias) */
+    file(path: string, options?: {
+        root?: string;
+        etag?: boolean;
+    }): NextRushResponse;
+    /** Send file response */
+    sendFile(path: string, options?: {
+        root?: string;
+        etag?: boolean;
+    }): NextRushResponse;
+    /** Send download response */
+    download(path: string, filename?: string): NextRushResponse;
+    /** Redirect response */
+    redirect(url: string, status?: number): NextRushResponse;
+    /** Permanent redirect (301) */
+    redirectPermanent(url: string): NextRushResponse;
+    /** Temporary redirect (307) */
+    redirectTemporary(url: string): NextRushResponse;
+    /** Set response status */
+    status(code: number): NextRushResponse;
+    /** Set response header */
+    set(name: string, value: string | number | string[]): NextRushResponse;
+    /** Set response header (alias) */
+    header(field: string, value: string): NextRushResponse;
+    /** Get response header */
+    get(name: string): string | number | string[] | undefined;
+    /** Remove response header */
+    remove(name: string): NextRushResponse;
+    /** Remove response header (implementation method) */
+    removeHeader(field: string): NextRushResponse;
+    /** Set response type */
+    type(type: string): NextRushResponse;
+    /** Set response length */
+    length(length: number): NextRushResponse;
+    /** Set response etag */
+    etag(etag: string): NextRushResponse;
+    /** Set response last modified */
+    lastModified(date: Date): NextRushResponse;
+    /** Set cookie */
+    cookie(name: string, value: string, options?: CookieOptions): NextRushResponse;
+    /** Clear cookie */
+    clearCookie(name: string, options?: CookieOptions): NextRushResponse;
+    /** Set cache headers */
+    cache(seconds: number): NextRushResponse;
+    /** Disable caching */
+    noCache(): NextRushResponse;
+    /** Set CORS headers */
+    cors(origin?: string): NextRushResponse;
+    /** Set security headers */
+    security(): NextRushResponse;
+    /** Enable compression hint */
+    compress(): NextRushResponse;
+    /** Send success response */
+    success(data: unknown, message?: string): void;
+    /** Send error response */
+    error(message: string, code?: number, details?: unknown): void;
+    /** Send paginated response */
+    paginate(data: unknown[], page: number, limit: number, total: number): void;
+    /** Get content type from file extension */
+    getContentTypeFromExtension(ext: string): string;
+    /** Get smart content type from file path */
+    getSmartContentType(filePath: string): string;
+    /** Generate ETag from stats */
+    generateETag(stats: unknown): string;
+    /** Convert data to CSV */
+    convertToCSV(data: unknown[]): string;
+    /** Add timing header */
+    time(label?: string): NextRushResponse;
+    /** Get nested value from object */
+    getNestedValue(obj: unknown, path: string): unknown;
+    /** Check if value is truthy */
+    isTruthy(value: unknown): boolean;
+}
 /**
- * Apply middleware UNLESS a condition is true (opposite of when)
- *
- * @example
- * const authExceptPublic = unless(
- *   (req) => req.path.startsWith('/public'),
- *   requireAuth
- * );
+ * Koa-style context interface
  */
-declare function unless(condition: (req: NextRushRequest) => boolean, middleware: ExpressMiddleware$1): ExpressMiddleware$1;
+interface Context {
+    /** Request object (Express-like) */
+    req: NextRushRequest;
+    /** Response object (Express-like) */
+    res: NextRushResponse;
+    /** Request body (Express-like) */
+    body: unknown;
+    /** Request method */
+    method: string;
+    /** Request URL */
+    url: string;
+    /** Request path */
+    path: string;
+    /** Request headers */
+    headers: IncomingMessage['headers'];
+    /** Query parameters */
+    query: ParsedUrlQuery;
+    /** Route parameters */
+    params: Record<string, string>;
+    /** Request ID for tracing */
+    id: string | undefined;
+    /** Request ID for logging (alternative to id) */
+    requestId?: string;
+    /** Request-specific logger */
+    logger?: {
+        log: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+        warn: (...args: unknown[]) => void;
+        info: (...args: unknown[]) => void;
+    };
+    /** State object for middleware communication */
+    state: Record<string, unknown>;
+    /** Request start time */
+    startTime: number;
+    /** Get client IP */
+    ip: string;
+    /** Check if request is secure */
+    secure: boolean;
+    /** Request protocol */
+    protocol: string;
+    /** Request hostname */
+    hostname: string;
+    /** Request host */
+    host: string;
+    /** Request origin */
+    origin: string;
+    /** Request href */
+    href: string;
+    /** Request search */
+    search: string;
+    /** Request search params */
+    searchParams: URLSearchParams;
+    /** Response status */
+    status: number;
+    /** Response headers */
+    responseHeaders: Record<string, string | number | string[]>;
+    /** Throw an error */
+    throw(status: number, message?: string): never;
+    /** Assert a condition */
+    assert(condition: unknown, status: number, message?: string): asserts condition;
+    /** Check if response is fresh */
+    fresh(): boolean;
+    /** Check if response is stale */
+    stale(): boolean;
+    /** Check if request is idempotent */
+    idempotent(): boolean;
+    /** Check if request is cacheable */
+    cacheable(): boolean;
+    /** Set response header (Koa-style) */
+    set(name: string, value: string | number | string[]): void;
+    /** Send a file using the enhanced response */
+    sendFile(path: string, options?: {
+        root?: string;
+        etag?: boolean;
+    }): void;
+    /** Render HTML from a template string or a template name under viewsDir */
+    render(templateOrName: string, data?: Record<string, unknown>, options?: {
+        layout?: string;
+    }): Promise<void>;
+    /** Send JSON response (convenience for ctx.res.json) */
+    json(data: unknown): void;
+    /** Send response data (convenience for ctx.res.send) */
+    send(data: string | Buffer | object): void;
+    /** Redirect response (convenience for ctx.res.redirect) */
+    redirect(url: string, statusCode?: number): void;
+    /** Set cookie (convenience for ctx.res.cookie) */
+    cookie(name: string, value: string, options?: CookieOptions): NextRushResponse;
+}
 /**
- * Give middleware a name for easier debugging and tracking
- *
- * @example
- * app.use(named('rate-limiter', rateLimitMiddleware));
- * app.use(named('auth-check', authMiddleware));
+ * Next function for middleware
  */
-declare function named(name: string, middleware: ExpressMiddleware$1): ExpressMiddleware$1;
+type Next = () => Promise<void>;
 /**
- * Create a group of middleware that can be applied together
- *
- * @example
- * const securityGroup = group([cors(), helmet(), rateLimit()]);
- * app.use('/api', securityGroup);
+ * Middleware function type
  */
-declare function group(middlewares: ExpressMiddleware$1[]): ExpressMiddleware$1;
-
+type Middleware = (ctx: Context, next: Next) => Promise<void>;
 /**
- * 📁 Static Files Types & Interfaces
- * Core type definitions for NextRush Static Files system
+ * Route handler function type
  */
-
+type RouteHandler = (ctx: Context) => Promise<void> | void;
+/** Dotfiles policy for static files */
+type DotfilesPolicy = 'ignore' | 'deny' | 'allow';
+/** Options for StaticFilesPlugin */
+interface StaticFilesOptions {
+    /** Absolute directory to serve files from */
+    root: string;
+    /** URL prefix to mount under, e.g., "/static"; default: '' (root) */
+    prefix?: `/${string}` | '';
+    /** Default index file to serve for directories; set false to disable */
+    index?: string | false;
+    /** If true, call next() on 404 instead of sending 404; default: false */
+    fallthrough?: boolean;
+    /** If true, redirect directory request without trailing slash to slash; default: true */
+    redirect?: boolean;
+    /** Send Cache-Control max-age seconds; default: 0 (no explicit caching) */
+    maxAge?: number;
+    /** Add immutable directive to Cache-Control when maxAge > 0; default: false */
+    immutable?: boolean;
+    /** Control dotfiles serving; default: 'ignore' (404) */
+    dotfiles?: DotfilesPolicy;
+    /** Additional extensions to try when file not found (e.g., ['.html']); default: [] */
+    extensions?: string[];
+    /** Hook to customize headers */
+    setHeaders?: (ctx: Context, absolutePath: string, stat: StatsLike) => void;
+}
+/** Stats-like interface for static files */
+interface StatsLike {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    size: number;
+    mtime: Date;
+}
+/** Options for TemplatePlugin */
+interface TemplatePluginOptions {
+    /** Directory containing template files */
+    viewsDir?: string;
+    /** Enable template caching; default: true */
+    cache?: boolean;
+    /** Custom helper functions */
+    helpers?: Record<string, (value: unknown, ...args: unknown[]) => unknown>;
+    /** Preloaded partial templates */
+    partials?: Record<string, string>;
+    /** Enable loading partials from viewsDir; default: true */
+    enableFilePartials?: boolean;
+    /** File extension for partials; default: '.html' */
+    partialExt?: string;
+}
+/** Template helper function type */
+type TemplateHelper = (value: unknown, ...args: unknown[]) => unknown;
+/** Template render options */
+interface TemplateRenderOptions {
+    /** Layout template to wrap content in */
+    layout?: string;
+}
 /**
- * Static files statistics
+ * Route configuration object (Fastify-style)
  */
-interface StaticStats {
-    totalRequests: number;
-    cacheHits: number;
-    compressionHits: number;
-    bytesServed: number;
-    filesCached: number;
-    cacheSize: number;
-    mounts: number;
-    uptime: number;
+interface RouteConfig {
+    /** Route handler */
+    handler: RouteHandler;
+    /** Route middleware */
+    middleware?: Middleware[];
+    /** Route schema validation */
+    schema?: {
+        body?: Record<string, unknown>;
+        query?: Record<string, unknown>;
+        params?: Record<string, unknown>;
+        response?: Record<string, unknown>;
+    };
+    /** Route options */
+    options?: {
+        /** Route name */
+        name?: string;
+        /** Route description */
+        description?: string;
+        /** Route tags */
+        tags?: string[];
+        /** Route version */
+        version?: string;
+        /** Route deprecated */
+        deprecated?: boolean;
+        /** Route summary */
+        summary?: string;
+        /** Route external docs */
+        externalDocs?: {
+            description: string;
+            url: string;
+        };
+    };
 }
-
 /**
- * 📁 NextRush Static Files Plugin
+ * Route data with handler and middleware
+ */
+interface RouteData {
+    handler: RouteHandler;
+    middleware: Middleware[];
+}
+/**
+ * Router interface for modular routing
+ */
+interface Router {
+    /** Register GET route */
+    get(path: string, handler: RouteHandler | RouteConfig): Router;
+    /** Register POST route */
+    post(path: string, handler: RouteHandler | RouteConfig): Router;
+    /** Register PUT route */
+    put(path: string, handler: RouteHandler | RouteConfig): Router;
+    /** Register DELETE route */
+    delete(path: string, handler: RouteHandler | RouteConfig): Router;
+    /** Register PATCH route */
+    patch(path: string, handler: RouteHandler | RouteConfig): Router;
+    /** Register middleware */
+    use(middleware: Middleware): Router;
+    /** Register sub-router */
+    use(prefix: string, router: Router): Router;
+    /** Get router middleware */
+    getMiddleware(): Middleware[];
+    /** Get router routes */
+    getRoutes(): Map<string, RouteData>;
+}
+/**
+ * Application interface (forward declaration)
+ */
+interface Application {
+    /** Register GET route */
+    get(path: string, handler: RouteHandler | RouteConfig): Application;
+    /** Register POST route */
+    post(path: string, handler: RouteHandler | RouteConfig): Application;
+    /** Register PUT route */
+    put(path: string, handler: RouteHandler | RouteConfig): Application;
+    /** Register DELETE route */
+    delete(path: string, handler: RouteHandler | RouteConfig): Application;
+    /** Register PATCH route */
+    patch(path: string, handler: RouteHandler | RouteConfig): Application;
+    /** Register middleware */
+    use(middleware: Middleware): Application;
+    /** Register router */
+    use(prefix: string, router: Router): Application;
+    /** Create router */
+    router(): Router;
+    /** Start the server */
+    listen(port?: number, callback?: () => void): unknown;
+    listen(port?: number, host?: string, callback?: () => void): unknown;
+    /** Get the underlying HTTP server */
+    getServer(): unknown;
+    /** Gracefully shutdown the application */
+    shutdown(): Promise<void>;
+    /** Create CORS middleware */
+    cors(options?: CorsOptions): Middleware;
+    /** Create helmet middleware */
+    helmet(options?: HelmetOptions): Middleware;
+    /** Create JSON body parser middleware */
+    json(options?: EnhancedBodyParserOptions): Middleware;
+    /** Create URL-encoded body parser middleware */
+    urlencoded(options?: EnhancedBodyParserOptions): Middleware;
+    /** Create text body parser middleware */
+    text(options?: EnhancedBodyParserOptions): Middleware;
+    /** Create rate limiter middleware */
+    rateLimit(options?: RateLimiterOptions): Middleware;
+    /** Create logger middleware */
+    logger(options?: LoggerOptions): Middleware;
+    /** Create compression middleware */
+    compression(options?: CompressionOptions): Middleware;
+    /** Create request ID middleware */
+    requestId(options?: RequestIdOptions): Middleware;
+    /** Create timer middleware */
+    timer(options?: TimerOptions): Middleware;
+    /** Create smart body parser middleware */
+    smartBodyParser(options?: EnhancedBodyParserOptions): Middleware;
+    /** Create exception filter middleware */
+    exceptionFilter(filters?: ExceptionFilter[]): Middleware;
+    /** Simple Events API for Express-style event handling */
+    events: {
+        /** Emit a simple string-based event */
+        emit(eventName: string, data?: any): Promise<void>;
+        /** Listen for a simple string-based event */
+        on(eventName: string, handler: (data: any) => void | Promise<void>): () => void;
+        /** Listen for a simple string-based event (once) */
+        once(eventName: string, handler?: (data: any) => void | Promise<void>): Promise<any>;
+        /** Remove all listeners for an event */
+        off(eventName: string): void;
+        /** Remove all listeners */
+        removeAllListeners(): void;
+        /** Get list of event names that have listeners */
+        eventNames(): string[];
+        /** Get number of listeners for an event */
+        listenerCount(eventName: string): number;
+        /** Get maximum number of listeners */
+        getMaxListeners(): number;
+        /** Set maximum number of listeners */
+        setMaxListeners(n: number): any;
+    };
+    /** Advanced Event System for CQRS and Event Sourcing */
+    eventSystem: {
+        /** Emit events */
+        emit(event: any): Promise<void>;
+        /** Subscribe to events */
+        subscribe(eventType: string, handler: (event: any) => void | Promise<void>): {
+            unsubscribe(): void;
+        };
+        /** Additional advanced methods available but not typed here for brevity */
+        [key: string]: any;
+    };
+    /** Logger instance (set by LoggerPlugin) - overrides logger method when plugin is installed */
+    loggerInstance?: {
+        error: (message: string, context?: Record<string, unknown>) => void;
+        warn: (message: string, context?: Record<string, unknown>) => void;
+        info: (message: string, context?: Record<string, unknown>) => void;
+        debug: (message: string, context?: Record<string, unknown>) => void;
+        trace: (message: string, context?: Record<string, unknown>) => void;
+        log: (message: string, context?: Record<string, unknown>) => void;
+    };
+    /** Register a WebSocket route (exact path or with trailing * wildcard) */
+    ws?: (path: string, handler: WSHandler) => Application;
+    /** Register a WebSocket middleware executed before the handler */
+    wsUse?: (middleware: WSMiddleware) => Application;
+    /** Broadcast a message to all sockets or a specific room */
+    wsBroadcast?: (message: string, room?: string) => Application;
+    /** Register a static files route */
+    static?: (prefix: string, root: string, options?: StaticFilesOptions) => Application;
+    /** Register template engine and view directory */
+    setViewEngine?: (engine: string, viewsDir?: string, options?: TemplatePluginOptions) => Application;
+    /** Add template helper */
+    helper?: (name: string, fn: (value: unknown, ...args: unknown[]) => unknown) => Application;
+    /** Add template partial */
+    partial?: (name: string, template: string) => Application;
+}
+
+/**
+ * Base plugin class for NextRush v2
  *
- * Enterprise-grade static file serving with:
- * - 🗜️ Smart compression (gzip/brotli)
- * - 💾 Intelligent LRU caching
- * - 📡 Range requests for streaming
- * - 🔒 Comprehensive security
- * - 🚀 High-performance optimization
- * - 📱 SPA support with fallback
+ * @packageDocumentation
  */
 
 /**
- * NextRush Static Files Plugin
+ * Plugin interface
  */
-declare class StaticFilesPlugin extends BasePlugin {
+interface Plugin {
+    /** Plugin name */
+    name: string;
+    /** Plugin version */
+    version: string;
+    /** Plugin description */
+    description?: string;
+    /** Plugin author */
+    author?: string;
+    /** Plugin homepage */
+    homepage?: string;
+    /** Plugin license */
+    license?: string;
+    /** Plugin keywords */
+    keywords?: string[];
+    /** Install plugin on application */
+    install(app: Application): void;
+    /** Plugin initialization */
+    init?(): void | Promise<void>;
+    /** Plugin cleanup */
+    cleanup?(): void | Promise<void>;
+    /** Plugin configuration validation */
+    validateConfig?(): boolean;
+    /** Plugin health check */
+    healthCheck?(): Promise<boolean>;
+}
+/**
+ * Plugin metadata interface
+ */
+interface PluginMetadata {
     name: string;
-    private cacheManager;
-    private compressionHandler;
-    private mimeTypeHandler;
-    private rangeHandler;
-    private securityHandler;
-    private mounts;
-    private stats;
-    private maintenanceInterval;
-    constructor(registry: PluginRegistry);
-    /**
-     * Install static file serving capabilities
+    version: string;
+    description?: string;
+    author?: string;
+    homepage?: string;
+    license?: string;
+    keywords?: string[];
+    dependencies?: string[];
+    conflicts?: string[];
+}
+/**
+ * Base plugin class that all plugins should extend
+ *
+ * @example
+ * ```typescript
+ * import { BasePlugin } from 'nextrush-v2';
+ * import type { Application } from 'nextrush-v2';
+ *
+ * export class MyPlugin extends BasePlugin {
+ *   name = 'MyPlugin';
+ *   version = '1.0.0';
+ *   description = 'A custom plugin';
+ *
+ *   install(app: Application): void {
+ *     // Plugin installation logic
+ *     app.use((req, res, next) => {
+ *       // Middleware logic
+ *       next();
+ *     });
+ *   }
+ *
+ *   async init(): Promise<void> {
+ *     // Plugin initialization
+ *   }
+ *
+ *   async cleanup(): Promise<void> {
+ *     // Plugin cleanup
+ *   }
+ * }
+ * ```
+ */
+declare abstract class BasePlugin implements Plugin {
+    abstract name: string;
+    abstract version: string;
+    abstract onInstall(app: Application): void;
+    description?: string;
+    author?: string;
+    homepage?: string;
+    license?: string;
+    keywords?: string[];
+    dependencies?: string[];
+    conflicts?: string[];
+    protected app?: Application;
+    protected config: Record<string, unknown>;
+    protected isInitialized: boolean;
+    protected isInstalled: boolean;
+    /**
+     * Install the plugin on an application
      */
     install(app: Application): void;
     /**
-     * Start the plugin
+     * Abstract method that plugins must implement
      */
-    start(): void;
     /**
-     * Stop the plugin
+     * Get plugin metadata
      */
-    stop(): void;
+    getMetadata(): PluginMetadata;
     /**
-     * Get comprehensive statistics
+     * Set plugin configuration
      */
-    getStats(): StaticStats & {
-        cache: any;
-    };
+    setConfig(config: Record<string, unknown>): void;
     /**
-     * Add static mount
+     * Get plugin configuration
      */
-    private addMount;
+    getConfig(): Record<string, unknown>;
     /**
-     * Handle incoming requests
+     * Get a specific configuration value
      */
-    private handleRequest;
+    getConfigValue<T>(key: string, defaultValue?: T): T | undefined;
     /**
-     * Serve file from specific mount
+     * Check if plugin is installed
      */
-    private serveFromMount;
+    isPluginInstalled(): boolean;
     /**
-     * Serve directory with index files
+     * Check if plugin is initialized
      */
-    private serveDirectory;
+    isPluginInitialized(): boolean;
     /**
-     * Serve individual file with all optimizations
+     * Register middleware with the application
      */
-    private serveFile;
+    protected registerMiddleware(middleware: Middleware): void;
     /**
-     * Create optimized cache entry
+     * Log plugin message
      */
-    private createCacheEntry;
+    protected log(message: string): void;
     /**
-     * Handle conditional requests (ETag, If-Modified-Since)
+     * Log plugin error
      */
-    private handleConditionalRequest;
+    protected logError(message: string, error?: Error): void;
     /**
-     * Handle range requests
+     * Log plugin warning
      */
-    private handleRangeRequest;
+    protected logWarning(message: string): void;
     /**
-     * Send file with optimized headers and compression
+     * Log plugin debug message
      */
-    private sendFile;
+    protected logDebug(message: string): void;
     /**
-     * Serve SPA fallback
+     * Emit plugin event
      */
-    private serveSpaFallback;
+    protected emit(event: string, ...args: unknown[]): void;
     /**
-     * Set cache control headers
+     * Create a middleware that wraps the plugin's functionality
      */
-    private setCacheControl;
+    protected createMiddleware(handler: (ctx: Context, next: () => Promise<void>) => void | Promise<void>): Middleware;
     /**
-     * Utility methods
+     * Create an async middleware that wraps the plugin's functionality
      */
-    private shouldCache;
-    private isPathUnderMount;
-    private normalizePath;
-    private parseMaxAge;
+    protected createAsyncMiddleware(handler: (ctx: Context, next: () => Promise<void>) => Promise<void>): Middleware;
     /**
-     * Initialize modular components
+     * Validate plugin configuration
      */
-    private initializeComponents;
+    validateConfig(): boolean;
     /**
-     * Start maintenance tasks
+     * Plugin health check
      */
-    private startMaintenance;
+    healthCheck(): Promise<boolean>;
     /**
-     * Stop maintenance tasks
+     * Get plugin status
      */
-    private stopMaintenance;
+    getStatus(): Record<string, unknown>;
 }
 
 /**
- * 🚀 NextRush Performance-Optimized Plugin System
+ * Logger Types and Interfaces for NextRush v2
  *
- * Reduces plugin overhead from 12 plugins to 3-5 essential plugins
- * for maximum performance in production environments.
- *
- * Expected Performance Improvement: +25-30% (400-500 RPS)
- */
-
-/**
- * Plugin loading strategy based on environment
- */
-declare enum PluginMode {
-    PERFORMANCE = "performance",// 4 plugins - max performance
-    DEVELOPMENT = "development",// 6 plugins - debugging tools
-    FULL_FEATURES = "full"
+ * @packageDocumentation
+ */
+declare enum LogLevel {
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3,
+    TRACE = 4
+}
+interface LogEntry {
+    timestamp: Date | string;
+    level: LogLevel | string;
+    message: string;
+    context?: Record<string, unknown>;
+    error?: Error;
+}
+interface LoggerConfig extends Record<string, unknown> {
+    level?: LogLevel;
+    format?: 'json' | 'text' | 'simple';
+    timestamp?: boolean;
+    colors?: boolean;
+    maxEntries?: number;
+    flushInterval?: number;
+    maxMemoryUsage?: number;
+    asyncFlush?: boolean;
+    transports?: Array<{
+        type: 'console' | 'file' | 'stream';
+        options?: Record<string, unknown>;
+    }>;
+}
+/**
+ * Transport interface
+ */
+interface Transport {
+    name: string;
+    level: string;
+    write(entry: LogEntry): void | Promise<void>;
 }
-/**
- * Create plugins based on mode
- */
-declare function createPlugins(registry: PluginRegistry, mode?: PluginMode): any[];
 
 /**
- * 🚀 NextRush Application - Complete, Type-Safe Framework
+ * Core Logger Plugin for NextRush v2
  *
- * Zero `any` usage, proper overloads, createRoute feature, enterprise-grade typing
+ * @packageDocumentation
  */
 
-interface ApplicationOptions {
-    router?: Router;
-    routerOptions?: RouterOptions;
-    errorHandler?: ErrorHandler;
-    timeout?: number;
-    maxRequestSize?: number;
-    enableEvents?: boolean;
-    enableWebSocket?: boolean;
-    caseSensitive?: boolean;
-    strict?: boolean;
-    pluginMode?: PluginMode;
-    bodyParser?: {
-        debug?: boolean;
-        maxSize?: number;
-        timeout?: number;
-        enableStreaming?: boolean;
-        autoDetectContentType?: boolean;
-        [key: string]: any;
-    };
-}
-interface StaticOptions {
-    maxAge?: string | number;
-    etag?: boolean;
-    index?: string | string[] | false;
-    dotfiles?: 'allow' | 'deny' | 'ignore';
-    extensions?: string[] | false;
-    immutable?: boolean;
-    redirect?: boolean;
-    spa?: boolean;
-    compress?: boolean | 'auto';
-    memoryCache?: boolean;
-    acceptRanges?: boolean;
-    cacheControl?: string;
-    setHeaders?: (res: any, path: string) => void;
-}
-interface RouteDefinition {
-    method: HttpMethod;
-    path: Path;
-    handler: RouteHandler$1 | ExpressHandler$1;
-    middleware?: (MiddlewareHandler$1 | ExpressMiddleware$1)[];
-    name?: string;
-    description?: string;
-}
-/**
- * 🔥 NextRush Application - Enterprise-Grade with Proper Typing
- */
-declare class Application extends BaseComponent {
-    private router;
-    private errorHandler;
-    private httpServer?;
-    private appOptions;
-    events?: SimpleEventEmitter;
-    private viewsDirectory?;
-    private pluginRegistry;
-    constructor(applicationOptions?: ApplicationOptions);
-    /**
-     * Install method required by BaseComponent
-     */
-    install(): void;
-    testMethod(): string;
-    /**
-     * 🔌 Initialize the plugin system
-     */
-    private initializePlugins;
-    /**
-     * GET method with comprehensive overloads - Express-style compatibility
-     */
-    get(path: Path, handler: ExpressHandler$1): Application;
-    get(path: Path, handler: RouteHandler$1): Application;
-    get(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    get(path: Path, middleware: ExpressMiddleware$1, handler: RouteHandler$1): Application;
-    get(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    get(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: RouteHandler$1): Application;
-    get(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    get(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, middleware3: ExpressMiddleware$1, handler: RouteHandler$1): Application;
-    /**
-     * POST method with comprehensive overloads - Express-style compatibility
-     */
-    post(path: Path, handler: ExpressHandler$1): Application;
-    post(path: Path, handler: RouteHandler$1): Application;
-    post(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    post(path: Path, middleware: ExpressMiddleware$1, handler: RouteHandler$1): Application;
-    post(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    post(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: RouteHandler$1): Application;
-    /**
-     * PUT method with comprehensive overloads - Express-style compatibility
-     */
-    put(path: Path, handler: ExpressHandler$1): Application;
-    put(path: Path, handler: RouteHandler$1): Application;
-    put(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    put(path: Path, middleware: ExpressMiddleware$1, handler: RouteHandler$1): Application;
-    put(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    put(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: RouteHandler$1): Application;
+declare class LoggerPlugin extends BasePlugin {
+    name: string;
+    version: string;
+    config: LoggerConfig;
+    private entries;
+    private flushTimer?;
+    private _transports;
+    private eventListeners;
+    constructor(config?: LoggerConfig);
+    onInstall(app: Application): void;
+    private startFlushTimer;
+    private stopFlushTimer;
+    private addEntry;
+    /**
+     * Check memory usage and flush if necessary
+     */
+    private checkMemoryUsage;
+    private flush;
+    private writeToTransport;
+    /**
+     * Write latest entry to all transports
+     */
+    private writeToTransports;
+    error(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    debug(message: string, context?: Record<string, unknown>): void;
+    trace(message: string, context?: Record<string, unknown>): void;
+    log(message: string, context?: Record<string, unknown>): void;
+    getEntries(): LogEntry[];
+    clear(): void;
+    setLevel(level: LogLevel | string): void;
     /**
-     * DELETE method with comprehensive overloads - Express-style compatibility
+     * Add a transport
      */
-    delete(path: Path, handler: ExpressHandler$1): Application;
-    delete(path: Path, handler: RouteHandler$1): Application;
-    delete(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    delete(path: Path, middleware: ExpressMiddleware$1, handler: RouteHandler$1): Application;
-    delete(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    delete(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: RouteHandler$1): Application;
+    addTransport(transport: Transport): void;
     /**
-     * PATCH method with comprehensive overloads - Express-style compatibility
+     * Remove a transport by name
      */
-    patch(path: Path, handler: ExpressHandler$1): Application;
-    patch(path: Path, handler: RouteHandler$1): Application;
-    patch(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    patch(path: Path, middleware: ExpressMiddleware$1, handler: RouteHandler$1): Application;
-    patch(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    patch(path: Path, middleware1: ExpressMiddleware$1, middleware2: ExpressMiddleware$1, handler: RouteHandler$1): Application;
+    removeTransport(name: string): void;
     /**
-     * HEAD method with comprehensive overloads - Express-style compatibility
+     * Add event listener
      */
-    head(path: Path, handler: ExpressHandler$1): Application;
-    head(path: Path, handler: RouteHandler$1): Application;
-    head(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    head(path: Path, middleware: ExpressMiddleware$1, handler: RouteHandler$1): Application;
+    on(event: string, listener: (entry: LogEntry) => void): void;
     /**
-     * OPTIONS method with comprehensive overloads - Express-style compatibility
+     * Remove event listener
      */
-    options(path: Path, handler: ExpressHandler$1): Application;
-    options(path: Path, handler: RouteHandler$1): Application;
-    options(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    options(path: Path, middleware: ExpressMiddleware$1, handler: RouteHandler$1): Application;
+    off(event: string, listener: (entry: LogEntry) => void): void;
     /**
-     * ALL method - matches all HTTP methods with comprehensive overloads
+     * Log a message (internal method for testing)
      */
-    all(path: Path, handler: ExpressHandler$1): Application;
-    all(path: Path, handler: RouteHandler$1): Application;
-    all(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): Application;
-    all(path: Path, middleware: ExpressMiddleware$1, handler: RouteHandler$1): Application;
+    logMessage(level: LogLevel | string, message: string, context?: Record<string, unknown>): void;
     /**
-     * Use middleware with proper overloads - Express-style compatibility
+     * Get transports (for testing)
      */
-    use(middleware: (req: NextRushRequest, res: NextRushResponse, next: () => void) => void | Promise<void>): Application;
-    use(middleware: (context: RequestContext, next: () => Promise<void>) => void | Promise<void>): Application;
-    use(path: Path, middleware: (req: NextRushRequest, res: NextRushResponse, next: () => void) => void | Promise<void>): Application;
-    use(path: Path, middleware: (context: RequestContext, next: () => Promise<void>) => void | Promise<void>): Application;
-    use(path: Path, router: Router): Application;
+    getTransports(): Transport[];
     /**
-     * Create a route definition without immediately registering it
+     * Get transports property (for testing)
      */
-    createRoute(definition: RouteDefinition): Route;
-    /**
-     * Register a pre-created route
-     */
-    addCreatedRoute(route: Route): Application;
-    /**
-     * Create and register route in one step
-     */
-    route(definition: RouteDefinition): Application;
-    private templateEngine?;
-    private templateOptions;
-    /**
-     * Set the template engine for Ultimate Template support
-     */
-    setTemplateEngine(engine: any): this;
-    /**
-     * Start the server - BaseComponent method
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the server - BaseComponent method
-     */
-    stop(): Promise<void>;
-    private addRoute;
-    private convertHandler;
-    private convertMiddleware;
-    private generateRouteId;
-    private createServer;
+    get transports(): Transport[];
+    cleanup(): void;
 }
 
 /**
- * 🔄 Event-Driven Architecture Plugin - NextRush Framework
+ * Logger Factory Functions for NextRush v2
  *
- * Provides comprehensive event-driven capabilities with pub/sub patterns,
- * event sourcing, and reactive programming features.
+ * @packageDocumentation
  */
 
 /**
- * Event middleware options
+ * Create minimal logger for testing
  */
-interface EventMiddlewareOptions {
-    autoEmit?: boolean;
-    events?: string[];
-    includeRequest?: boolean;
-    includeResponse?: boolean;
-}
+declare function createMinimalLogger(): LoggerPlugin;
 /**
- * Event pipeline configuration
+ * Create development logger
  */
-interface EventPipeline {
-    name: string;
-    events: string[];
-    handler: (eventData: any) => void | Promise<void>;
-    filters?: Array<(data: any) => boolean>;
-}
+declare function createDevLogger(): LoggerPlugin;
 /**
- * 🔄 Event-Driven Architecture Plugin
+ * Create production logger
  */
-declare class EventDrivenPlugin extends BasePlugin {
-    name: string;
-    private eventEmitter;
-    private listeners;
-    private pipelines;
-    private eventHistory;
-    private maxHistorySize;
-    constructor(registry: PluginRegistry);
-    /**
-     * Install event-driven capabilities
-     */
-    install(app: Application): void;
-    /**
-     * Start the event-driven plugin
-     */
-    start(): void;
-    /**
-     * Stop the event-driven plugin
-     */
-    stop(): void;
-    /**
-     * 📢 Add event listener
-     */
-    addEventListener(event: string, handler: (...args: any[]) => void | Promise<void>, options?: {
-        priority?: number;
-    }): string;
-    /**
-     * 📢 Add one-time event listener
-     */
-    addEventListenerOnce(event: string, handler: (...args: any[]) => void | Promise<void>): string;
-    /**
-     * 🚫 Remove event listener
-     */
-    removeEventListener(event: string, listenerId?: string): boolean;
-    /**
-     * 📡 Emit event
-     */
-    emitEvent(event: string, data?: any): void;
-    /**
-     * 🔧 Create event pipeline
-     */
-    createPipeline(name: string, config: Omit<EventPipeline, 'name'>): void;
-    /**
-     * ⚡ Trigger specific pipeline
-     */
-    triggerPipeline(name: string, data?: any): void;
-    /**
-     * 🔧 Create event middleware
-     */
-    createEventMiddleware(options?: EventMiddlewareOptions): (req: NextRushRequest, res: NextRushResponse, next: () => void) => void;
-    /**
-     * 📊 Get event statistics
-     */
-    getEventStats(): any;
-    /**
-     * 📝 Add event to history
-     */
-    private addToHistory;
-    /**
-     * ⚡ Trigger pipelines for event
-     */
-    private triggerPipelinesForEvent;
-    /**
-     * 🔧 Generate unique ID
-     */
-    private generateId;
-}
+declare function createProdLogger(): LoggerPlugin;
 
 /**
- * 🛡️ Validation & Sanitization Plugin - NextRush Framework
+ * Logger Transport implementations for NextRush v2
  *
- * Provides comprehensive input validation, sanitization, and security features
- * following the unified plugin architecture.
+ * @packageDocumentation
  */
 
 /**
- * Validation rule interface
- */
-interface ValidationRule {
-    required?: boolean;
-    type?: 'string' | 'number' | 'email' | 'url' | 'boolean' | 'array' | 'object';
-    minLength?: number;
-    maxLength?: number;
-    min?: number;
-    max?: number;
-    pattern?: RegExp;
-    in?: any[];
-    custom?: (value: any) => boolean | string;
-}
-/**
- * Validation schema
+ * Console Transport
  */
-interface ValidationSchema {
-    [field: string]: ValidationRule;
+declare class ConsoleTransport implements Transport {
+    name: string;
+    private _level;
+    private _levelString;
+    constructor(level?: LogLevel | string);
+    get levelString(): string;
+    get level(): string;
+    set level(value: LogLevel | string);
+    write(entry: LogEntry): void;
 }
 /**
- * Sanitization options
+ * File Transport
  */
-interface SanitizationOptions {
-    removeHtml?: boolean;
-    escapeHtml?: boolean;
-    trim?: boolean;
-    lowercase?: boolean;
-    uppercase?: boolean;
-    removeSpecialChars?: boolean;
-    allowedTags?: string[];
+declare class FileTransport implements Transport {
+    name: string;
+    private _level;
+    private filePath;
+    private _levelString;
+    constructor(filePath: string, level?: LogLevel | string);
+    get levelString(): string;
+    get level(): string;
+    set level(value: LogLevel | string);
+    write(entry: LogEntry): Promise<void>;
 }
 /**
- * Validation result
+ * HTTP Transport
  */
-interface ValidationResult {
-    isValid: boolean;
-    errors: Record<string, string[]>;
-    sanitized: Record<string, any>;
+declare class HttpTransport implements Transport {
+    name: string;
+    private _level;
+    private url;
+    private _levelString;
+    constructor(url: string, level?: LogLevel | string);
+    get levelString(): string;
+    get level(): string;
+    set level(value: LogLevel | string);
+    write(entry: LogEntry): Promise<void>;
 }
 /**
- * 🛡️ Validation & Sanitization Plugin
+ * Stream Transport
  */
-declare class ValidationPlugin extends BasePlugin {
+declare class StreamTransport implements Transport {
     name: string;
-    constructor(registry: PluginRegistry);
-    /**
-     * Install validation capabilities
-     */
-    install(app: Application): void;
-    /**
-     * Start the validation plugin
-     */
-    start(): void;
-    /**
-     * Stop the validation plugin
-     */
-    stop(): void;
-    /**
-     * 🔍 Validate request against schema
-     */
-    private validateRequest;
-    /**
-     * 🧹 Sanitize data recursively
-     */
-    private sanitizeData;
-    /**
-     * 🧹 Sanitize string value
-     */
-    private sanitizeString;
-    /**
-     * 🔍 Validate specific type
-     */
-    private validateType;
-    /**
-     * 🔍 Check if value is empty
-     */
-    private isEmpty;
+    private _level;
+    private stream;
+    private _levelString;
+    constructor(stream: NodeJS.WritableStream, level?: LogLevel | string);
+    get levelString(): string;
+    get level(): string;
+    set level(value: LogLevel | string);
+    write(entry: LogEntry): void;
 }
 
 /**
- * 🔐 Auth Plugin Interfaces - NextRush Framework
+ * Core Application class for NextRush v2
  *
- * Type definitions for authentication, authorization, and session management.
+ * @packageDocumentation
  */
+
 /**
- * JWT configuration options
- */
-interface JwtOptions {
-    secret: string;
-    algorithm?: 'HS256' | 'HS384' | 'HS512';
-    expiresIn?: string | number;
-    issuer?: string;
-    audience?: string;
-    notBefore?: string | number;
-}
-/**
- * Session configuration options
+ * Create a new NextRush application instance
+ *
+ * @param options - Application configuration options
+ * @returns Application instance
+ *
+ * @example
+ * ```typescript
+ * import { createApp } from 'nextrush-v2';
+ *
+ * const app = createApp({
+ *   port: 3000,
+ *   host: 'localhost',
+ *   cors: true,
+ * });
+ *
+ * app.use(app.cors());
+ * app.use(app.helmet());
+ *
+ * app.get('/hello', (ctx) => {
+ *   ctx.res.json({ message: 'Hello, World!' });
+ * });
+ *
+ * app.listen(3000, () => {
+ *   console.log('Server running on http://localhost:3000');
+ * });
+ * ```
  */
-interface SessionOptions {
-    secret: string;
-    name?: string;
-    maxAge?: number;
-    secure?: boolean;
-    httpOnly?: boolean;
-    sameSite?: 'strict' | 'lax' | 'none';
-    rolling?: boolean;
-    store?: SessionStore;
-}
+declare function createApp(options?: ApplicationOptions): Application;
+
 /**
- * User interface for authentication
+ * Context factory for NextRush v2
+ *
+ * @packageDocumentation
  */
-interface User {
-    id: string | number;
-    username?: string;
-    email?: string;
-    roles?: string[];
-    permissions?: string[];
-    metadata?: Record<string, unknown>;
-}
+
 /**
- * Session data interface
+ * Create a Koa-style context object with Express-like design
+ *
+ * @param req - HTTP request object
+ * @param res - HTTP response object
+ * @param options - Application options
+ * @returns Enhanced context object
+ *
+ * @example
+ * ```typescript
+ * import { createContext } from '@/core/context';
+ *
+ * const ctx = createContext(req, res, options);
+ * console.log(ctx.req.ip()); // Client IP
+ * ctx.res.json({ message: 'Hello' });
+ * ```
  */
-interface SessionData {
-    id: string;
-    userId: string | number;
-    data: Record<string, unknown>;
-    createdAt: number;
-    lastAccess: number;
-    expiresAt: number;
-}
+declare function createContext(req: IncomingMessage | NextRushRequest, res: ServerResponse | NextRushResponse, _options: Required<ApplicationOptions>): Context;
+
 /**
- * Session store interface
+ * Static Files Plugin for NextRush v2
+ *
+ * Express/Koa/Fastify-inspired static file serving with strong DX and security.
+ *
+ * - Prefix-based mounting (virtual path)
+ * - Safe path resolution (prevents traversal)
+ * - ETag/Last-Modified + 304 handling
+ * - Range requests (single range)
+ * - Cache-Control with maxAge/immutable
+ * - HEAD support
+ * - Optional index.html serving and directory redirect
+ * - Dotfiles policy (ignore/deny/allow)
+ * - Optional custom header hook
+ *
+ * @packageDocumentation
  */
-interface SessionStore {
-    get(sessionId: string): Promise<SessionData | undefined>;
-    set(sessionId: string, data: SessionData): Promise<void>;
-    destroy(sessionId: string): Promise<void>;
-    cleanup(): Promise<void>;
-}
+
 /**
- * RBAC permissions interface
+ * StaticFilesPlugin
  */
-interface Permission {
-    resource: string;
-    action: string;
-    conditions?: Record<string, any>;
+declare class StaticFilesPlugin extends BasePlugin {
+    private readonly userOptions;
+    name: string;
+    version: string;
+    description: string;
+    private options;
+    constructor(userOptions: StaticFilesOptions);
+    onInstall(app: Application): void;
+    private normalizeOptions;
+    private createStaticMiddleware;
+    private failOrNext;
 }
+
 /**
- * Role interface
- */
-interface Role {
+ * Template Plugin for NextRush v2
+ *
+ * Safe, minimal, helper-based HTML templating with auto-escaping.
+ *
+ * Features:
+ * - Auto-escape by default; triple mustache {{{expr}}} to output raw
+ * - Helpers: stripHTML, json, upper, lower, date, safe
+ * - Partials: {{> partialName}} (inline or file-based when viewsDir is set)
+ * - Nested path access: {{user.name}}, {{profile.bio}}
+ * - File-based rendering when viewsDir provided; otherwise inline templates
+ * - Simple cache of compiled templates (in-memory)
+ * - Block syntax:
+ *   - Conditionals: {{#if cond}}...{{else}}...{{/if}}
+ *   - Loops: {{#each items}}...{{/each}} with {{this}}, {{@index}}, {{@key}}
+ *   - With: {{#with obj}}...{{/with}}
+ * - Layouts (when viewsDir provided): render(template, data, { layout: 'layout.html' })
+ */
+
+declare class TemplatePlugin extends BasePlugin {
     name: string;
-    permissions: Permission[];
-    inherits?: string[];
+    version: string;
+    description: string;
+    private engine;
+    constructor(options?: TemplatePluginOptions);
+    onInstall(app: Application): void;
+}
+
+declare class WSRoomManager extends EventEmitter {
+    private rooms;
+    add(socket: WSConnection, room: string): void;
+    remove(socket: WSConnection, room: string): void;
+    leaveAll(socket: WSConnection): void;
+    broadcast(room: string, data: string | Buffer, exclude?: WSConnection): void;
+    getRooms(): string[];
 }
 
 /**
- * 🛡️ RBAC Manager - NextRush Framework
+ * WebSocket Plugin Type Augmentation
  *
- * Role-Based Access Control with hierarchical permissions and inheritance.
+ * This file provides type-safe WebSocket functionality through smart type casting
+ * and utility types for perfect TypeScript intelligence.
  */
 
-/**
- * Predefined roles for common use cases
- */
-declare const CommonRoles: {
-    admin: () => Role;
-    user: () => Role;
-    moderator: () => Role;
-    editor: () => Role;
-    viewer: () => Role;
-};
+interface WebSocketApplication extends Application {
+    ws: (path: string, handler: WSHandler) => WebSocketApplication;
+    wsUse: (middleware: WSMiddleware) => WebSocketApplication;
+    wsBroadcast: (message: string, room?: string) => WebSocketApplication;
+}
+declare function hasWebSocketSupport(app: Application): app is WebSocketApplication;
+declare function withWebSocket(app: Application): WebSocketApplication;
 
 /**
- * 🔥 CORS Types - High-Performance Type Definitions
- * Zero memory leaks, enterprise-grade CORS configuration
+ * WebSocket Plugin for NextRush v2 - Context-based Architecture
+ * Provides WebSocket functionality through context enhancement
  */
-type CorsOrigin = string | string[] | boolean | CorsOriginFunction;
-type CorsOriginFunction = (origin: string | undefined, callback: (err: Error | null, allow?: boolean) => void) => void;
-type CorsMethod = 'GET' | 'HEAD' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS';
-interface CorsOptions {
-    /** Allowed origins for CORS requests */
-    origin?: CorsOrigin;
-    /** Allowed HTTP methods */
-    methods?: string | string[] | CorsMethod[];
-    /** Allowed request headers */
-    allowedHeaders?: string | string[];
-    /** Headers exposed to the client */
-    exposedHeaders?: string | string[];
-    /** Allow credentials in cross-origin requests */
-    credentials?: boolean;
-    /** Preflight cache duration in seconds */
-    maxAge?: number;
-    /** Continue to next middleware after preflight */
-    preflightContinue?: boolean;
-    /** Success status code for OPTIONS requests */
-    optionsSuccessStatus?: number;
-    /** Handle preflight requests automatically */
-    preflight?: boolean;
-    /** Enable origin caching for performance */
-    cacheOrigins?: boolean;
-    /** Cache TTL in milliseconds */
-    cacheTtl?: number;
-    /** Enable CORS metrics collection */
-    enableMetrics?: boolean;
-}
-declare enum CorsPresetType {
-    ALLOW_ALL = "allow_all",
-    STRICT = "strict",
-    DEVELOPMENT = "development",
-    PRODUCTION = "production",
-    API_ONLY = "api_only",
-    MICROSERVICE = "microservice"
-}
 
 /**
- * 🔥 CORS Presets - Production-Ready Configurations
- * Optimized CORS configurations for different environments and use cases
+ * Enhanced Context with WebSocket functionality
  */
-
+interface WSContext extends Context {
+    /** WebSocket connection (available when request is upgraded) */
+    ws?: WSConnection;
+    /** Check if request is WebSocket upgrade request */
+    isWebSocket: boolean;
+    /** WebSocket room manager */
+    wsRooms: WSRoomManager;
+}
 /**
- * 🚀 CORS Presets Factory
+ * WebSocket Plugin for NextRush v2
+ *
+ * Enhances context with WebSocket functionality following v2 architecture patterns
  */
-declare class CorsPresets {
+declare class WebSocketPlugin extends BasePlugin {
+    name: string;
+    version: string;
+    description: string;
+    private options;
+    private roomManager;
+    private connections;
+    private routes;
+    private middlewares;
+    private heartbeatTimer;
+    constructor(options?: WebSocketPluginOptions);
+    /**
+     * Install WebSocket plugin - adds WebSocket middleware to app
+     */
+    onInstall(app: Application): void;
+    /**
+     * Start heartbeat timer for connection cleanup
+     */
+    private startHeartbeat;
+    /**
+     * Cleanup plugin resources
+     */
+    cleanup(): void;
+    /**
+     * Setup HTTP upgrade event handler
+     */
+    private setupUpgradeHandler;
+    /**
+     * Handle HTTP to WebSocket upgrade
+     */
+    private handleUpgrade;
     /**
-     * Allow all origins - suitable for public APIs (use with caution)
+     * Execute WebSocket middlewares
      */
-    static allowAll(): CorsOptions;
+    private executeMiddlewares;
     /**
-     * Strict CORS - only specified origins with credentials
+     * Handle WebSocket upgrade in middleware context
      */
-    static strict(allowedOrigins: string[]): CorsOptions;
+    private handleWebSocketUpgrade;
     /**
-     * Development-friendly CORS - very permissive for testing
+     * Verify WebSocket upgrade request
      */
-    static development(): CorsOptions;
+    private verifyUpgrade;
     /**
-     * Production-safe CORS with security focus
+     * Perform WebSocket handshake
      */
-    static production(allowedOrigins: string[]): CorsOptions;
+    private performHandshake;
     /**
-     * API-only CORS (no credentials, suitable for public APIs)
+     * Generate WebSocket accept key
      */
-    static apiOnly(allowedOrigins?: string[]): CorsOptions;
+    private generateAcceptKey;
     /**
-     * Microservice CORS - for service-to-service communication
+     * Check if request is WebSocket upgrade request
      */
-    static microservice(serviceOrigins: string[]): CorsOptions;
+    private isWebSocketRequest;
     /**
-     * WebApp CORS - for traditional web applications
+     * Check if path matches registered WebSocket routes
      */
-    static webApp(allowedOrigins: string[]): CorsOptions;
+    private matchPath;
     /**
-     * SPA (Single Page Application) CORS
+     * Reject WebSocket connection
      */
-    static spa(allowedOrigins: string[]): CorsOptions;
+    private rejectConnection;
     /**
-     * Get preset by type
+     * Get all active connections
      */
-    static getPreset(type: CorsPresetType, origins?: string[]): CorsOptions;
+    getConnections(): WSConnection[];
     /**
-     * Get environment-based preset
+     * Broadcast message to all connections
      */
-    static getEnvironmentPreset(env?: string, origins?: string[]): CorsOptions;
+    broadcast(message: string, room?: string): void;
     /**
-     * Merge multiple CORS options (later options override earlier ones)
+     * Get connection statistics
      */
-    static merge(...optionsArray: CorsOptions[]): CorsOptions;
+    getStats(): {
+        totalConnections: number;
+        rooms: string[];
+        handlers: number;
+    };
 }
 
 /**
- * 🛡️ Rate Limiter Plugin - NextRush Framework
+ * 🚀 Smart Body Parser Dispatcher - NextRush v2
+ *
+ * INTELLIGENT CONTENT-TYPE AWARE PARSER LOADER
+ *
+ * 🎯 **PERFORMANCE BREAKTHROUGH:**
+ * - 🔥 Only loads the parser you need based on Content-Type
+ * - ⚡ JSON request → Only loads JSON parser (~150 lines)
+ * - 🌊 Multipart request → Only loads multipart parser (~200 lines)
+ * - 🎭 Form request → Only loads URL-encoded parser (~150 lines)
+ * - 📄 Text request → Only loads text parser (~100 lines)
+ * - 💾 Raw request → Only loads raw parser (~100 lines)
+ *
+ * OLD WAY: Every request loads 1,032 lines ❌
+ * NEW WAY: Each request loads only 100-200 lines ✅
  *
- * Built-in rate limiting with memory and Redis backends.
- * Prevents abuse and controls traffic with configurable windows and limits.
+ * @author NextRush Framework Team
+ * @version 2.0.0
  */
 
 /**
- * Rate limiter options
+ * 🌍 Global smart parser instance (removed unused variable)
  */
-interface RateLimiterOptions {
-    windowMs?: number;
-    max?: number;
-    message?: string;
-    statusCode?: number;
-    standardHeaders?: boolean;
-    legacyHeaders?: boolean;
-    skipSuccessfulRequests?: boolean;
-    skipFailedRequests?: boolean;
-    keyGenerator?: (req: NextRushRequest) => string;
-    skip?: (req: NextRushRequest) => boolean;
-    handler?: (req: NextRushRequest, res: NextRushResponse) => void;
-    store?: RateLimiterStore;
-    onLimitReached?: (req: NextRushRequest, options: RateLimiterOptions) => void;
-}
 /**
- * Rate limiter store interface
+ * 🚀 Create smart body parser middleware
  */
-interface RateLimiterStore {
-    get(key: string): Promise<RateLimiterData | undefined>;
-    set(key: string, data: RateLimiterData, windowMs: number): Promise<void>;
-    increment(key: string, windowMs: number): Promise<RateLimiterData>;
-    reset(key: string): Promise<void>;
-    resetAll(): Promise<void>;
-}
+declare function smartBodyParser(options?: EnhancedBodyParserOptions): Middleware;
+
 /**
- * Rate limiter data structure
+ * Compression middleware for NextRush v2
+ *
+ * @packageDocumentation
  */
-interface RateLimiterData {
-    count: number;
-    resetTime: number;
-    firstHit?: number;
-}
 
 /**
- * 📊 Metrics Plugin Interfaces - NextRush Framework
- *
- * Core type definitions for the metrics and monitoring system.
+ * Compression middleware factory
  */
+declare function compression(options?: CompressionOptions): Middleware;
 
 /**
- * Simple metrics configuration for end users
+ * CORS Middleware for NextRush v2
+ *
+ * High-performance CORS implementation with pre-computed headers
+ * and optimized origin checking for enterprise applications.
+ *
+ * @packageDocumentation
  */
-interface MetricsOptions {
-    endpoint?: string;
-    enableHealthCheck?: boolean;
-    collectDefaultMetrics?: boolean;
-    prefix?: string;
-    defaultLabels?: Record<string, string>;
-    customMetrics?: CustomMetric[];
-    authentication?: (req: NextRushRequest) => boolean;
-}
+
 /**
- * Custom metric definition
+ * Create CORS middleware
+ *
+ * @param options - CORS configuration options
+ * @returns CORS middleware function
+ *
+ * @example
+ * ```typescript
+ * import { createApp } from 'nextrush-v2';
+ * import { cors } from '@/core/middleware';
+ *
+ * const app = createApp();
+ *
+ * // Basic CORS
+ * app.use(cors());
+ *
+ * // Advanced CORS
+ * app.use(cors({
+ *   origin: ['https://app.example.com', 'https://admin.example.com'],
+ *   credentials: true,
+ *   methods: ['GET', 'POST', 'PUT', 'DELETE'],
+ *   allowedHeaders: ['Content-Type', 'Authorization', 'X-API-Key'],
+ * }));
+ * ```
  */
-interface CustomMetric {
-    name: string;
-    type: 'counter' | 'gauge' | 'histogram' | 'summary';
-    help: string;
-    labels?: string[];
-    buckets?: number[];
-    quantiles?: number[];
-}
+declare function cors(options?: CorsOptions): Middleware$1;
+
 /**
- * Metric value with metadata
+ * Helmet Middleware for NextRush v2
+ *
+ * Provides security headers to protect against common vulnerabilities
+ *
+ * @packageDocumentation
  */
-interface MetricValue {
-    value: number;
-    labels?: Record<string, string>;
-    timestamp: number;
-    samples?: number;
-    sum?: number;
-}
+
 /**
- * HTTP request metrics
+ * Create Helmet middleware for security headers
+ *
+ * @param options - Helmet configuration options
+ * @returns Helmet middleware function
+ *
+ * @example
+ * ```typescript
+ * import { helmet } from '@/core/middleware/helmet';
+ *
+ * const app = createApp();
+ * app.use(helmet());
+ *
+ * // With custom options
+ * app.use(helmet({
+ *   contentSecurityPolicy: {
+ *     directives: {
+ *       defaultSrc: ["'self'"],
+ *       scriptSrc: ["'self'", "'unsafe-inline'"],
+ *     },
+ *   },
+ * }));
+ * ```
  */
-interface RequestMetrics {
-    total: number;
-    active: number;
-    byMethod: Record<string, number>;
-    byStatus: Record<number, number>;
-    averageResponseTime: number;
-    errors: number;
-    p95ResponseTime: number;
-    p99ResponseTime: number;
-}
+declare function helmet(options?: HelmetOptions): Middleware$1;
+
 /**
- * System performance metrics
+ * Logger Middleware for NextRush v2
+ *
+ * Provides request logging functionality
+ *
+ * @packageDocumentation
  */
-interface SystemMetrics {
-    uptime: number;
-    memory: {
-        used: number;
-        total: number;
-        heap: NodeJS.MemoryUsage;
-    };
-    cpu: {
-        usage: number;
-        load: number[];
-    };
-    process: {
-        pid: number;
-        uptime: number;
-    };
-}
+
 /**
- * Health check status
+ * Create logger middleware
+ *
+ * @param options - Logger configuration options
+ * @returns Logger middleware function
+ *
+ * @example
+ * ```typescript
+ * import { logger } from '@/core/middleware/logger';
+ *
+ * const app = createApp();
+ *
+ * // Basic logging
+ * app.use(logger());
+ *
+ * // Advanced logging
+ * app.use(logger({
+ *   format: 'combined',
+ *   level: 'info',
+ *   colorize: true,
+ *   showResponseTime: true,
+ *   showUserAgent: true,
+ * }));
+ * ```
  */
-interface HealthStatus {
-    status: 'healthy' | 'unhealthy' | 'degraded';
-    timestamp: number;
-    uptime: number;
-    checks: Record<string, HealthCheckResult>;
-}
+declare function logger(options?: LoggerOptions): Middleware$1;
+
 /**
- * Individual health check result
+ * Rate Limiter Middleware for NextRush v2
+ *
+ * Provides rate limiting functionality to prevent abuse
+ *
+ * @packageDocumentation
  */
-interface HealthCheckResult {
-    status: 'pass' | 'fail' | 'warn';
-    message?: string;
-    duration: number;
-    timestamp: number;
-}
+
 /**
- * Simple health check function
+ * Create rate limiter middleware
+ *
+ * @param options - Rate limiter configuration options
+ * @returns Rate limiter middleware function
+ *
+ * @example
+ * ```typescript
+ * import { rateLimit } from '@/core/middleware/rate-limiter';
+ *
+ * const app = createApp();
+ *
+ * // Basic rate limiting
+ * app.use(rateLimit({ windowMs: 15 * 60 * 1000, max: 100 }));
+ *
+ * // Advanced rate limiting
+ * app.use(rateLimit({
+ *   windowMs: 15 * 60 * 1000,
+ *   max: 100,
+ *   message: 'Too many requests from this IP',
+ *   keyGenerator: (ctx) => ctx.ip,
+ *   skip: (ctx) => ctx.path.startsWith('/public'),
+ * }));
+ * ```
  */
-type HealthCheckFunction = () => Promise<{
-    status: 'pass' | 'fail' | 'warn';
-    message?: string;
-}>;
+declare function rateLimit(options?: RateLimiterOptions): Middleware$1;
 
 /**
- * 🎯 Template Engine Types
- * Core interfaces and types for the NextRush template system
+ * Request ID Middleware for NextRush v2
+ *
+ * Provides request ID generation and tracking functionality
+ *
+ * @packageDocumentation
  */
 
 /**
- * Template context for variable substitution
+ * Create request ID middleware
+ *
+ * @param options - Request ID configuration options
+ * @returns Request ID middleware function
+ *
+ * @example
+ * ```typescript
+ * import { requestId } from '@/core/middleware/request-id';
+ *
+ * const app = createApp();
+ *
+ * // Basic request ID
+ * app.use(requestId());
+ *
+ * // Advanced request ID
+ * app.use(requestId({
+ *   headerName: 'X-Correlation-ID',
+ *   generator: () => generateUUID(),
+ *   addResponseHeader: true,
+ *   echoHeader: true,
+ * }));
+ * ```
  */
-interface TemplateContext {
-    [key: string]: any;
-}
+declare function requestId(options?: RequestIdOptions): Middleware$1;
+
 /**
- * Path aliases for template resolution
+ * Timer middleware for NextRush v2
+ *
+ * @packageDocumentation
  */
-interface PathAliases {
-    [alias: string]: string;
-}
+
 /**
- * Helper function registry
+ * Create timer middleware
+ *
+ * @param options - Timer configuration options
+ * @returns Timer middleware function
+ *
+ * @example
+ * ```typescript
+ * import { timer } from '@/core/middleware/timer';
+ *
+ * const app = createApp();
+ *
+ * // Basic timer
+ * app.use(timer());
+ *
+ * // Advanced timer
+ * app.use(timer({
+ *   header: 'X-Response-Time',
+ *   digits: 3,
+ *   suffix: 'ms',
+ *   logSlow: true,
+ *   logSlowThreshold: 1000,
+ * }));
+ * ```
  */
-interface HelperRegistry {
-    [name: string]: (...args: any[]) => any;
-}
+declare function timer(options?: TimerOptions): Middleware$1;
+
 /**
- * Filter function registry
+ * Request Enhancer for NextRush v2
+ *
+ * @packageDocumentation
  */
-interface FilterRegistry {
-    [name: string]: (value: any, ...args: any[]) => any;
-}
+
 /**
- * Internationalization configuration
+ * Enhanced request interface with Express-like properties and methods
  */
-interface I18nConfig {
-    locale?: string;
-    fallback?: string;
-    translations?: {
-        [locale: string]: {
-            [key: string]: string;
-        };
+interface EnhancedRequest extends IncomingMessage {
+    params: Record<string, string>;
+    query: ParsedUrlQuery;
+    body: unknown;
+    pathname: string;
+    originalUrl: string;
+    path: string;
+    files: Record<string, unknown>;
+    cookies: Record<string, string>;
+    session: Record<string, unknown>;
+    locals: Record<string, unknown>;
+    startTime: number;
+    fresh: boolean;
+    stale: boolean;
+    middlewareStack?: string[];
+    param(name: string): string | undefined;
+    header(name: string): string | undefined;
+    get(name: string): string | undefined;
+    sanitizeObject(obj: unknown, options?: unknown): unknown;
+    getRequestTiming(): unknown;
+    ip: string;
+    secure: boolean;
+    protocol: string;
+    hostname(): string;
+    fullUrl(): string;
+    is(type: string): boolean;
+    accepts(types: string | string[]): string | false;
+    parseCookies(): Record<string, string>;
+    validate(rules: unknown): unknown;
+    sanitize(value: unknown, options?: unknown): unknown;
+    isValidEmail(email: string): boolean;
+    isValidUrl(url: string): boolean;
+    sanitizeValue(value: unknown, rule: unknown): unknown;
+    fingerprint(): string;
+    userAgent(): {
+        raw: string;
+        browser: string;
+        os: string;
+        device: string;
+        isMobile: boolean;
+        isBot: boolean;
     };
-    directory?: string;
-    defaultLocale?: string;
-    locales?: string[];
-}
-/**
- * Template engine configuration options
- */
-interface TemplateOptions {
-    views?: string;
-    layouts?: string;
-    partials?: string;
-    components?: string;
-    cache?: boolean;
-    engine?: 'mustache' | 'handlebars' | 'jsx' | 'auto';
-    pathAliases?: PathAliases;
-    encoding?: BufferEncoding;
-    extensions?: string[];
-    globals?: TemplateContext;
-    helpers?: HelperRegistry;
-    filters?: FilterRegistry;
-    i18n?: I18nConfig;
-    minify?: boolean;
-    debug?: boolean;
-    watchFiles?: boolean;
-    streaming?: boolean;
-    defaultExtension?: string;
-}
-/**
- * Template rendering options
- */
-interface RenderOptions {
-    engine?: string;
-    cache?: boolean;
-    layout?: string;
-    locals?: TemplateContext;
-    streaming?: boolean;
-    partials?: Record<string, string>;
-    helpers?: Record<string, Function>;
-    filters?: Record<string, Function>;
-    [key: string]: any;
-}
-/**
- * Template AST node types
- */
-interface TemplateNode {
-    type: 'text' | 'variable' | 'block' | 'component' | 'partial' | 'layout' | 'helper';
-    content?: string;
-    key?: string;
-    props?: TemplateContext;
-    children?: TemplateNode[];
-    escape?: boolean;
-    condition?: string;
-    iterator?: {
-        array: string;
-        item: string;
-        index?: string;
+    timing(): {
+        start: number;
+        duration: number;
+        timestamp: string;
     };
-    name?: string;
-    args?: any[];
-    start?: number;
-    end?: number;
-}
-/**
- * Template parsing result
- */
-interface ParseResult {
-    nodes: TemplateNode[];
-    metadata: {
-        dependencies: string[];
-        components: string[];
-        partials: string[];
-        layout?: string;
-        frontmatter?: any;
-        title?: string;
-        author?: string;
-        date?: string;
-        tags?: string[];
+    rateLimit(): {
+        limit: number;
+        remaining: number;
+        reset: number;
+        retryAfter: number;
     };
+    parseBrowser(ua: string): string;
+    parseOS(ua: string): string;
+    parseDevice(ua: string): string;
+    isBot(ua: string): boolean;
+    isMobile(ua: string): boolean;
 }
 /**
- * Compiled template result
- */
-interface CompileResult {
-    render: (context: TemplateContext, options?: RenderOptions) => Promise<string>;
-    renderStream: (context: TemplateContext, stream: Writable, options?: RenderOptions) => Promise<void>;
-    metadata: ParseResult['metadata'];
-}
-/**
- * Test rendering result interface
+ * Request Enhancer class for NextRush v2
+ *
+ * @example
+ * ```typescript
+ * import { RequestEnhancer } from '@/core/enhancers/request-enhancer';
+ *
+ * const enhancedReq = RequestEnhancer.enhance(req);
+ * console.log(enhancedReq.ip()); // Client IP
+ * console.log(enhancedReq.userAgent()); // User agent info
+ * ```
  */
-interface TestRenderResult {
-    html: string;
-    errors: string[];
-    metadata?: ParseResult['metadata'];
+declare class RequestEnhancer {
+    /**
+     * Enhance a Node.js IncomingMessage with NextRush v2 features
+     *
+     * @param req - The original HTTP request
+     * @returns Enhanced request with additional properties and methods
+     */
+    static enhance(req: IncomingMessage): EnhancedRequest;
 }
 
 /**
- * 🔧 Template Helpers and Filters
- * Built-in and custom helper functions for template rendering
+ * Response Enhancer for NextRush v2
+ *
+ * @packageDocumentation
  */
 
 /**
- * Helper and Filter Manager
+ * File options interface
  */
-declare class TemplateHelperManager {
-    private helpers;
-    private filters;
-    private i18nConfig;
-    constructor(i18nConfig?: I18nConfig);
-    /**
-     * Register a custom helper
-     */
-    registerHelper(name: string, fn: (...args: any[]) => any): void;
-    /**
-     * Register a custom filter
-     */
-    registerFilter(name: string, fn: (value: any, ...args: any[]) => any): void;
-    /**
-     * Get helper function
-     */
-    getHelper(name: string): ((...args: any[]) => any) | undefined;
-    /**
-     * Get filter function
-     */
-    getFilter(name: string): ((value: any, ...args: any[]) => any) | undefined;
-    /**
-     * Get all helpers
-     */
-    getAllHelpers(): HelperRegistry;
-    /**
-     * Get all filters
-     */
-    getAllFilters(): FilterRegistry;
-    /**
-     * Setup built-in helper functions
-     */
-    private setupBuiltinHelpers;
-    /**
-     * Setup built-in filter functions
-     */
-    private setupBuiltinFilters;
-    /**
-     * Translate a key using i18n configuration
-     */
-    private translate;
-    /**
-     * Translate plural forms
-     */
-    private translatePlural;
+interface FileOptions {
+    etag?: boolean;
+    root?: string;
 }
-
 /**
- * 🎨 Template Parser
- * Multi-syntax template parsing engine for NextRush
+ * Enhanced response interface with Express-like methods
  */
-
+interface EnhancedResponse extends ServerResponse {
+    locals: Record<string, unknown>;
+    status(code: number): EnhancedResponse;
+    json(data: unknown): void;
+    send(data: string | Buffer | object): void;
+    html(data: string): void;
+    text(data: string): void;
+    xml(data: string): void;
+    csv(data: unknown[], filename?: string): void;
+    stream(stream: NodeJS.ReadableStream, contentType?: string): void;
+    sendFile(filePath: string, options?: FileOptions): void;
+    file(filePath: string, options?: FileOptions): EnhancedResponse;
+    download(filePath: string, filename?: string, options?: FileOptions): void;
+    getSmartContentType(filePath: string): string;
+    generateETag(stats: unknown): string;
+    redirect(url: string, status?: number): void;
+    redirectPermanent(url: string): void;
+    redirectTemporary(url: string): void;
+    set(field: string | Record<string, string>, value?: string): EnhancedResponse;
+    header(field: string, value: string): EnhancedResponse;
+    removeHeader(field: string): EnhancedResponse;
+    remove(field: string): EnhancedResponse;
+    get(field: string): string | undefined;
+    type(type: string): EnhancedResponse;
+    length(length: number): EnhancedResponse;
+    etag(etag: string): EnhancedResponse;
+    lastModified(date: Date): EnhancedResponse;
+    cookie(name: string, value: string, options?: CookieOptions): EnhancedResponse;
+    clearCookie(name: string, options?: CookieOptions): EnhancedResponse;
+    render(template: string, data?: unknown): void;
+    getNestedValue(obj: unknown, path: string): unknown;
+    isTruthy(value: unknown): boolean;
+    cache(seconds: number): EnhancedResponse;
+    noCache(): EnhancedResponse;
+    cors(origin?: string): EnhancedResponse;
+    security(): EnhancedResponse;
+    compress(): EnhancedResponse;
+    success(data: unknown, message?: string): void;
+    error(message: string, code?: number, details?: unknown): void;
+    paginate(data: unknown[], page: number, limit: number, total: number): void;
+    getContentTypeFromExtension(ext: string): string;
+    convertToCSV(data: unknown[]): string;
+    time(label?: string): EnhancedResponse;
+}
 /**
- * Ultimate Template Parser - Handles multiple template syntaxes
+ * Response Enhancer class for NextRush v2
+ *
+ * @example
+ * ```typescript
+ * import { ResponseEnhancer } from '@/core/enhancers/response-enhancer';
+ *
+ * const enhancedRes = ResponseEnhancer.enhance(res);
+ * enhancedRes.json({ message: 'Hello World' });
+ * ```
  */
-declare class UltimateTemplateParser {
-    private pos;
-    private input;
-    private options;
-    constructor(input: string, options?: TemplateOptions);
-    /**
-     * Parse template content into AST nodes
-     */
-    parse(): ParseResult;
-    /**
-     * Parse a single template node
-     */
-    private parseNode;
-    /**
-     * Parse Handlebars-like syntax: {{variable}} {{#block}} {{>partial}}
-     */
-    private parseHandlebarsLike;
-    /**
-     * Parse JSX-like syntax: <% if %> <% for %> <%= variable %>
-     */
-    private parseJSXLike;
-    /**
-     * Parse React-like components: <Component prop="value">content</Component>
-     */
-    private parseComponent;
-    /**
-     * Parse block helpers: {{#if}} {{#each}}
-     */
-    private parseBlock;
-    /**
-     * Parse until a specific end tag is found
-     */
-    private parseUntil;
-    /**
-     * Parse plain text content
-     */
-    private parseText;
-    /**
-     * Peek ahead in the input string
-     */
-    private peek;
-    /**
-     * Check if the current position matches a regex
-     */
-    private peekRegex;
-    /**
-     * Consume a specific string if it matches current position
-     */
-    private consume;
+declare class ResponseEnhancer {
     /**
-     * Read until a specific end string is found
+     * Enhance a Node.js ServerResponse with NextRush v2 features
+     *
+     * @param res - The original HTTP response
+     * @returns Enhanced response with additional methods
      */
-    private readUntil;
+    static enhance(res: ServerResponse): EnhancedResponse;
 }
 
 /**
- * 🎨 Template Renderer
- * High-performance template rendering engine for NextRush
+ * Optimized Radix Tree Router for NextRush v2
+ *
+ * High-performance router with O(k) lookup performance
+ * where k is path length, not route count.
+ *
+ * Performance optimizations:
+ * - Zero-copy path splitting
+ * - LRU cache for frequent paths
+ * - Iterative traversal (no recursion)
+ * - Pre-allocated parameter objects
+ * - Optimized parameter matching
+ *
+ * @packageDocumentation
  */
 
 /**
- * Ultimate Template Renderer - High-performance rendering engine
+ * Route match result with pre-allocated parameter object
  */
-declare class UltimateTemplateRenderer {
-    private options;
-    private helperManager;
-    private globals;
-    private partials;
-    private components;
-    private layouts;
-    private templateCache;
-    constructor(options?: TemplateOptions);
-    /**
-     * Load template from file system
-     */
-    loadTemplate(templatePath: string, type?: 'template' | 'partial' | 'component' | 'layout'): Promise<ParseResult | null>;
+interface OptimizedRouteMatch {
+    handler: RouteHandler;
+    middleware: Middleware[];
+    params: Record<string, string>;
+    path: string;
+    compiled?: (ctx: any) => Promise<void>;
+}
+/**
+ * Optimized Router class with performance improvements
+ */
+declare class OptimizedRouter implements Router {
+    private root;
+    private middleware;
+    private prefix;
+    private cache;
+    private paramPool;
+    private maxPoolSize;
+    private poolHits;
+    private poolMisses;
+    private readonly staticRoutes;
+    constructor(prefix?: string, cacheSize?: number);
     /**
-     * Get base directory for template type
+     * Optimized parameter object management
      */
-    private getBaseDirectory;
+    private getParamObject;
     /**
-     * Render nodes to a writable stream
+     * Get pool statistics for monitoring
      */
-    renderStream(nodes: TemplateNode[], context: TemplateContext, stream: Writable, options?: RenderOptions): Promise<void>;
+    private getPoolStats;
     /**
-     * Render a single template node
+     * Register a GET route
      */
-    private renderNode;
+    get(path: string, handler: RouteHandler | RouteConfig): OptimizedRouter;
     /**
-     * Render helper function calls
+     * Register a POST route
      */
-    private renderHelper;
+    post(path: string, handler: RouteHandler | RouteConfig): OptimizedRouter;
     /**
-     * Render block elements (if, each)
+     * Register a PUT route
      */
-    private renderBlock;
+    put(path: string, handler: RouteHandler | RouteConfig): OptimizedRouter;
     /**
-     * Render partial templates
+     * Register a DELETE route
      */
-    private renderPartial;
+    delete(path: string, handler: RouteHandler | RouteConfig): OptimizedRouter;
     /**
-     * Render components
+     * Register a PATCH route
      */
-    private renderComponent;
+    patch(path: string, handler: RouteHandler | RouteConfig): OptimizedRouter;
     /**
-     * Render with layout
+     * Use middleware or create sub-router
      */
-    private renderLayout;
+    use(middlewareOrPrefix: string | Middleware, router?: Router): OptimizedRouter;
     /**
-     * Render template to string
+     * Get all registered routes for sub-router integration
      */
-    render(nodes: TemplateNode[], context: TemplateContext, options?: RenderOptions): Promise<string>;
+    getRoutes(): Map<string, RouteData>;
     /**
-     * Render with layout support
+     * Get router middleware
      */
-    renderWithLayout(parseResult: ParseResult, context: TemplateContext, options?: RenderOptions): Promise<string>;
+    getMiddleware(): Middleware[];
     /**
-     * Register a partial template
+     * 🔥 Inject compiled handler for a route (used by compiler)
+     * This allows the pre-compilation system to inject optimized handlers
      */
-    registerPartial(name: string, parseResult: ParseResult): void;
+    setCompiledHandler(method: string, pattern: string, compiledExecute: (ctx: any) => Promise<void>): void;
     /**
-     * Register a component template
+     * Get comprehensive cache and performance statistics
      */
-    registerComponent(name: string, parseResult: ParseResult): void;
+    getCacheStats(): {
+        cache: {
+            size: number;
+            hitRate: number;
+            hits: number;
+            misses: number;
+        };
+        pool: {
+            poolSize: number;
+            maxSize: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        performance: {
+            totalRoutes: number;
+            pathCacheSize: number;
+        };
+    };
     /**
-     * Register a layout template
+     * Get total number of registered routes
      */
-    registerLayout(name: string, parseResult: ParseResult): void;
+    private getTotalRoutes;
     /**
-     * Clear template cache
+     * Clear the route cache
      */
     clearCache(): void;
-}
-
-/**
- * 🎯 Simple Template Engine - Super Easy DX
- * One-line setup, zero configuration needed!
- * Hide all complexity behind clean API
- */
-
-/**
- * Simple template configuration options
- */
-interface SimpleTemplateOptions {
-    /** Enable caching for better performance (default: true) */
-    cache?: boolean;
-    /** Custom helpers for templates */
-    helpers?: HelperRegistry;
-    /** Enable debug mode in development */
-    debug?: boolean;
-}
-/**
- * 🚀 Create a simple template engine with one line!
- *
- * @example
- * ```typescript
- * // Super simple setup
- * const template = createTemplate();
- * app.setTemplateEngine(template);
- *
- * // With custom helpers
- * const template = createTemplate({
- *   helpers: {
- *     currency: (amount) => `$${amount.toFixed(2)}`
- *   }
- * });
- * ```
- */
-declare function createTemplate(options?: SimpleTemplateOptions): {
     /**
-     * Render template with data - super simple!
+     * Ultra-fast route finder with aggressive optimizations
      */
-    render(templateContent: string, data?: Record<string, any>): Promise<string>;
+    find(method: string, path: string): OptimizedRouteMatch | null;
     /**
-     * Validate template syntax (optional, but helpful for debugging)
+     * Hyper-optimized internal finder with minimal allocations
      */
-    validate(templateContent: string): {
-        valid: boolean;
-        errors: string[];
-    };
-};
-/**
- * 🎯 Quick setup for NextRush apps - ONE LINE!
- *
- * @example
- * ```typescript
- * import { quickTemplate } from 'next-rush';
- *
- * const app = createApp();
- * app.setTemplateEngine(quickTemplate());
- * ```
- */
-declare function quickTemplate(helpers?: HelperRegistry): {
+    private findInternalOptimized;
     /**
-     * Render template with data - super simple!
+     * Optimized route registration with O(k) insertion
      */
-    render(templateContent: string, data?: Record<string, any>): Promise<string>;
+    private registerRoute;
     /**
-     * Validate template syntax (optional, but helpful for debugging)
+     * Iteratively collect all routes from the tree (no recursion)
      */
-    validate(templateContent: string): {
-        valid: boolean;
-        errors: string[];
-    };
-};
+    private collectRoutesIterative;
+}
 /**
- * 🛠️ Advanced template setup (but still simple!)
+ * Create a new optimized router instance
+ *
+ * @param prefix - Optional route prefix
+ * @param cacheSize - Optional cache size (default: 1000)
+ * @returns OptimizedRouter instance
  *
  * @example
  * ```typescript
- * import { advancedTemplate } from 'next-rush';
+ * import { createOptimizedRouter } from 'nextrush-v2';
  *
- * const template = advancedTemplate({
- *   cache: true,
- *   debug: true,
- *   helpers: {
- *     myHelper: (value) => `Custom: ${value}`
- *   }
- * });
- * ```
- */
-declare function advancedTemplate(options: SimpleTemplateOptions): {
-    /**
-     * Render template with data - super simple!
-     */
-    render(templateContent: string, data?: Record<string, any>): Promise<string>;
-    /**
-     * Validate template syntax (optional, but helpful for debugging)
-     */
-    validate(templateContent: string): {
-        valid: boolean;
-        errors: string[];
-    };
-};
-/**
- * 🎨 Template with common web helpers pre-loaded
- */
-declare function webTemplate(): {
-    /**
-     * Render template with data - super simple!
-     */
-    render(templateContent: string, data?: Record<string, any>): Promise<string>;
-    /**
-     * Validate template syntax (optional, but helpful for debugging)
-     */
-    validate(templateContent: string): {
-        valid: boolean;
-        errors: string[];
-    };
-};
-
-/**
- * 🔧 Template Engine Utilities
- * Helper classes and utility functions for the template system
- */
-
-/**
- * HTML escaping utility
- */
-declare function escapeHTML(str: string): string;
-/**
- * Get nested value from object using dot notation
- */
-declare function getValue(context: Record<string, any>, key: string): any;
-/**
- * Simple condition evaluation for templates
- */
-declare function evaluateCondition(condition: string, context: Record<string, any>): boolean;
-/**
- * Parse YAML-like frontmatter
- */
-declare function parseFrontmatter(content: string): {
-    content: string;
-    frontmatter: any;
-};
-/**
- * Create slot map from child nodes for component rendering
- */
-declare function createSlotMap(children: any[]): {
-    [slotName: string]: any[];
-};
-/**
- * Resolve template path with proper extension handling
- */
-declare function resolveTemplatePath(templatePath: string, baseDir: string, defaultExtension?: string): string;
-
-/**
- * 🧪 Template Testing Utilities
- * Testing tools for template engine development and validation
- */
-
-/**
- * Test template rendering with error handling
- */
-declare function testTemplateRender(templateContent: string, data: TemplateContext, options?: TemplateOptions): Promise<TestRenderResult>;
-/**
- * Validate template syntax without rendering
- */
-declare function validateTemplateSyntax(templateContent: string, options?: TemplateOptions): {
-    valid: boolean;
-    errors: string[];
-};
-/**
- * Benchmark template rendering performance
- */
-declare function benchmarkTemplate(templateContent: string, data: TemplateContext, iterations?: number, options?: TemplateOptions): Promise<{
-    totalTime: number;
-    averageTime: number;
-    iterationsPerSecond: number;
-}>;
-/**
- * Compare template engines performance
- */
-declare function compareTemplateEngines(templateContent: string, data: TemplateContext, engines: Array<{
-    name: string;
-    options: TemplateOptions;
-}>, iterations?: number): Promise<Array<{
-    name: string;
-    totalTime: number;
-    averageTime: number;
-    iterationsPerSecond: number;
-}>>;
-
-/**
- * 🚀 NextRush Component Architecture Interfaces
- *
- * Clean, type-safe interfaces for the plugin-based architecture
- */
-/**
- * Minimal Application Interface - Core methods that plugins install
- * Provides full type inference for all HTTP methods and middleware
- */
-interface MinimalApplication {
-    get(path: Path, handler: RouteHandler$1): MinimalApplication;
-    get(path: Path, handler: ExpressHandler$1): MinimalApplication;
-    get(path: Path, middleware: MiddlewareHandler$1, handler: RouteHandler$1): MinimalApplication;
-    get(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): MinimalApplication;
-    get(path: Path, ...handlers: (RouteHandler$1 | ExpressHandler$1 | MiddlewareHandler$1 | ExpressMiddleware$1)[]): MinimalApplication;
-    post(path: Path, handler: RouteHandler$1): MinimalApplication;
-    post(path: Path, handler: ExpressHandler$1): MinimalApplication;
-    post(path: Path, middleware: MiddlewareHandler$1, handler: RouteHandler$1): MinimalApplication;
-    post(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): MinimalApplication;
-    post(path: Path, ...handlers: (RouteHandler$1 | ExpressHandler$1 | MiddlewareHandler$1 | ExpressMiddleware$1)[]): MinimalApplication;
-    put(path: Path, handler: RouteHandler$1): MinimalApplication;
-    put(path: Path, handler: ExpressHandler$1): MinimalApplication;
-    put(path: Path, middleware: MiddlewareHandler$1, handler: RouteHandler$1): MinimalApplication;
-    put(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): MinimalApplication;
-    put(path: Path, ...handlers: (RouteHandler$1 | ExpressHandler$1 | MiddlewareHandler$1 | ExpressMiddleware$1)[]): MinimalApplication;
-    delete(path: Path, handler: RouteHandler$1): MinimalApplication;
-    delete(path: Path, handler: ExpressHandler$1): MinimalApplication;
-    delete(path: Path, middleware: MiddlewareHandler$1, handler: RouteHandler$1): MinimalApplication;
-    delete(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): MinimalApplication;
-    delete(path: Path, ...handlers: (RouteHandler$1 | ExpressHandler$1 | MiddlewareHandler$1 | ExpressMiddleware$1)[]): MinimalApplication;
-    patch(path: Path, handler: RouteHandler$1): MinimalApplication;
-    patch(path: Path, handler: ExpressHandler$1): MinimalApplication;
-    patch(path: Path, middleware: MiddlewareHandler$1, handler: RouteHandler$1): MinimalApplication;
-    patch(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): MinimalApplication;
-    patch(path: Path, ...handlers: (RouteHandler$1 | ExpressHandler$1 | MiddlewareHandler$1 | ExpressMiddleware$1)[]): MinimalApplication;
-    head(path: Path, handler: RouteHandler$1): MinimalApplication;
-    head(path: Path, handler: ExpressHandler$1): MinimalApplication;
-    head(path: Path, middleware: MiddlewareHandler$1, handler: RouteHandler$1): MinimalApplication;
-    head(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): MinimalApplication;
-    head(path: Path, ...handlers: (RouteHandler$1 | ExpressHandler$1 | MiddlewareHandler$1 | ExpressMiddleware$1)[]): MinimalApplication;
-    options(path: Path, handler: RouteHandler$1): MinimalApplication;
-    options(path: Path, handler: ExpressHandler$1): MinimalApplication;
-    options(path: Path, middleware: MiddlewareHandler$1, handler: RouteHandler$1): MinimalApplication;
-    options(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): MinimalApplication;
-    options(path: Path, ...handlers: (RouteHandler$1 | ExpressHandler$1 | MiddlewareHandler$1 | ExpressMiddleware$1)[]): MinimalApplication;
-    all(path: Path, handler: RouteHandler$1): MinimalApplication;
-    all(path: Path, handler: ExpressHandler$1): MinimalApplication;
-    all(path: Path, middleware: MiddlewareHandler$1, handler: RouteHandler$1): MinimalApplication;
-    all(path: Path, middleware: ExpressMiddleware$1, handler: ExpressHandler$1): MinimalApplication;
-    all(path: Path, ...handlers: (RouteHandler$1 | ExpressHandler$1 | MiddlewareHandler$1 | ExpressMiddleware$1)[]): MinimalApplication;
-    use(handler: MiddlewareHandler$1): MinimalApplication;
-    use(handler: ExpressMiddleware$1): MinimalApplication;
-    use(path: Path, handler: MiddlewareHandler$1): MinimalApplication;
-    use(path: Path, handler: ExpressMiddleware$1): MinimalApplication;
-    use(pathOrHandler: Path | MiddlewareHandler$1 | ExpressMiddleware$1, handler?: MiddlewareHandler$1 | ExpressMiddleware$1): MinimalApplication;
-    static?(staticPath: string, options?: any): MinimalApplication;
-    serveStatic?(staticPath: string, options?: any): MinimalApplication;
-    render?(view: string, data?: any): Promise<string>;
-    setTemplateEngine?(engine: any): MinimalApplication;
-    setViews?(viewsPath: string): MinimalApplication;
-    json?(options?: any): MiddlewareHandler$1;
-    urlencoded?(options?: any): MiddlewareHandler$1;
-    raw?(options?: any): MiddlewareHandler$1;
-    text?(options?: any): MiddlewareHandler$1;
-    cors?(options?: any): MiddlewareHandler$1;
-    helmet?(options?: any): MiddlewareHandler$1;
-    ws?(path: string, handler: any): MinimalApplication;
-    websocket?(path: string, handler: any): MinimalApplication;
-    enableWebSocket?(options?: any): MinimalApplication;
-    listen(port: number, hostname?: string, callback?: () => void): Promise<void>;
-    close(): Promise<void>;
-    getPluginRegistry?(): any;
-    registerPlugin?(plugin: any): Promise<void>;
-    unregisterPlugin?(name: string): Promise<void>;
-}
-/**
- * Component lifecycle interface
- */
-interface Lifecycle {
-    readonly name: string;
-    install(app: MinimalApplication): void | Promise<void>;
-    start?(): void | Promise<void>;
-    stop?(): void | Promise<void>;
-}
-
-/**
- * 🔥 Optimized Custom Error Classes for NextRush Framework
- * Zero memory leaks, performance-optimized, enterprise-grade error handling
- */
-declare enum ErrorSeverity {
-    LOW = "low",
-    MEDIUM = "medium",
-    HIGH = "high",
-    CRITICAL = "critical"
-}
-declare enum ErrorCategory {
-    VALIDATION = "validation",
-    AUTHENTICATION = "authentication",
-    AUTHORIZATION = "authorization",
-    NETWORK = "network",
-    DATABASE = "database",
-    FILESYSTEM = "filesystem",
-    BUSINESS_LOGIC = "business_logic",
-    SYSTEM = "system",
-    EXTERNAL_SERVICE = "external_service"
-}
-/**
- * 🔥 High-Performance Base Error Class
- * - Memory-optimized with object pooling
- * - Conditional stack capture for performance
- * - Immutable properties for thread safety
- * - Rich metadata for debugging
- */
-declare abstract class NextRushError extends Error {
-    readonly code: string;
-    readonly statusCode: number;
-    readonly details: Readonly<Record<string, unknown>>;
-    readonly timestamp: number;
-    readonly severity: ErrorSeverity;
-    readonly category: ErrorCategory;
-    readonly correlationId?: string;
-    readonly retryable: boolean;
-    private static readonly errorPool;
-    private static readonly maxPoolSize;
-    constructor(message: string, code: string, statusCode?: number, details?: Record<string, unknown>, severity?: ErrorSeverity, category?: ErrorCategory, retryable?: boolean, correlationId?: string);
-    /**
-     * 🚀 High-performance JSON serialization
-     */
-    toJSON(): Record<string, unknown>;
-    /**
-     * 🚀 Smart stack capture decision
-     */
-    private shouldCaptureStack;
-    /**
-     * 🚀 Smart stack inclusion decision
-     */
-    private shouldIncludeStack;
-    /**
-     * 🚀 Generate correlation ID for error tracking
-     */
-    private generateCorrelationId;
-    /**
-     * 🚀 Static factory method with error pooling
-     */
-    static create<T extends NextRushError>(this: new (...args: any[]) => T, ...args: any[]): T;
-    /**
-     * 🚀 Check if error is retryable
-     */
-    isRetryable(): boolean;
-    /**
-     * 🚀 Check if error is critical
-     */
-    isCritical(): boolean;
-    /**
-     * 🚀 Get user-friendly message (sanitized for production)
-     */
-    getUserMessage(): string;
-}
-/**
- * 🚀 Client Errors (4xx)
- */
-declare class ValidationError extends NextRushError {
-    constructor(message: string, details?: Record<string, unknown>, correlationId?: string);
-    static field(fieldName: string, value: unknown, expected: string, correlationId?: string): ValidationError;
-    static schema(errors: Array<{
-        field: string;
-        message: string;
-    }>, correlationId?: string): ValidationError;
-}
-declare class NotFoundError extends NextRushError {
-    constructor(resource?: string, identifier?: string | number, correlationId?: string);
-}
-declare class MethodNotAllowedError extends NextRushError {
-    constructor(method: string, allowedMethods?: string[], correlationId?: string);
-}
-/**
- * 🚀 Server Errors (5xx)
- */
-declare class InternalServerError extends NextRushError {
-    constructor(message?: string, details?: Record<string, unknown>, correlationId?: string);
-}
-
-/**
- * 🔧 NextRush Middleware Types
- * Type definitions for middl# Named middleware interface wit// Built-in middleware option types using NextRush types
-export interface CorsOptions {
-  origin?: string | string[] | boolean | ((or# Middleware execution context# Advanced middleware types with NextRush types
-export type ConditionalMiddleware<TRequest = NextRushRequest, TResponse = NextRushResponse> = {
-  condition: ConditionalPredicate<TRequest, TResponse>;
-  middleware: Middleware<TRequest, TResponse>;
-};
-
-export type TimedMiddleware<TRequest = NextRushRequest, TResponse = NextRushResponse> = {
-  timeout: number;
-  middleware: Middleware<TRequest, TResponse>;
-  onTimeout?: (context: MiddlewareContext<TRequest, TResponse>) => void;
-};
-
-export type RetryableMiddleware<TRequest = NextRushRequest, TResponse = NextRushResponse> = {
-  maxRetries: number;
-  middleware: Middleware<TRequest, TResponse>;
-  shouldRetry?: (error: any, attempt: number) => boolean;
-  delay?: number | ((attempt: number) => number);
-};es
-export interface MiddlewareContext<TRequest = NextRushRequest, TResponse = NextRushResponse> {
-  req: TRequest;
-  res: TResponse;
-  next: NextFunction;
-  config?: MiddlewareConfig;
-  startTime?: number;
-  endTime?: number;
-  error?: any;
-  metadata?: Record<string, any>;
-}g | undefined, req: NextRushRequest) => boolean);
-  methods?: string | string[];
-  allowedHeaders?: string | string[];
-  exposedHeaders?: string | string[];
-  credentials?: boolean;
-  maxAge?: number;
-  preflightContinue?: boolean;
-  optionsSuccessStatus?: number;
-}types
-export interface NamedMiddleware<
-  TRequest = NextRushRequest,
-  TResponse = NextRushResponse,
-  TNextFunction = NextFunction
-> extends Middleware<TRequest, TResponse, TNextFunction> {
-  middlewareName: string;
-  config?: MiddlewareConfig;
-}tem using proper NextRush types
- */
-
-type NextFunction = (error?: any) => void;
-type Middleware<TRequest = NextRushRequest, TResponse = NextRushResponse, TNextFunction = NextFunction> = (req: TRequest, res: TResponse, next: TNextFunction) => void;
-type AsyncMiddleware<TRequest = NextRushRequest, TResponse = NextRushResponse, TNextFunction = NextFunction> = (req: TRequest, res: TResponse, next: TNextFunction) => Promise<void>;
-type ErrorMiddleware<TError = any, TRequest = NextRushRequest, TResponse = NextRushResponse, TNextFunction = NextFunction> = (error: TError, req: TRequest, res: TResponse, next: TNextFunction) => void;
-type RequestHandler<TRequest = NextRushRequest, TResponse = NextRushResponse, TNextFunction = NextFunction> = Middleware<TRequest, TResponse, TNextFunction>;
-type ErrorRequestHandler<TError = any, TRequest = NextRushRequest, TResponse = NextRushResponse, TNextFunction = NextFunction> = ErrorMiddleware<TError, TRequest, TResponse, TNextFunction>;
-
-/**
- * 🎛️ NextRush Middleware Presets - Unified Plugin Architecture
+ * const userRouter = createOptimizedRouter('/users', 2000);
  *
- * Pre-configured middleware stacks for common use cases.
- * Following copilot instructions - everything is now plugin-based.
+ * userRouter.get('/profile', async (ctx) => {
+ *   ctx.res.json({ user: 'profile' });
+ * });
  *
- * NOTE: CORS functionality now uses the enterprise-grade CorsPlugin
- * instead of built-in middleware for better performance and features.
- */
-
-/**
- * Available preset names
- */
-type PresetName = 'development' | 'production' | 'api' | 'fullFeatured';
-interface PresetOptions {
-    cors?: boolean | any;
-    helmet?: boolean | any;
-    logger?: boolean | any;
-    bodyParser?: boolean | any;
-    [key: string]: any;
-}
-/**
- * Development preset - Perfect for learning and debugging
- * Uses enterprise CORS plugin for consistency
- */
-declare function developmentPreset(options?: PresetOptions): ExpressMiddleware$1[];
-/**
- * Production preset - Security and performance optimized
- */
-declare function productionPreset(options?: PresetOptions): ExpressMiddleware$1[];
-/**
- * API preset - Perfect for REST APIs
- */
-declare function apiPreset(options?: PresetOptions): ExpressMiddleware$1[];
-/**
- * Minimal preset - Just the basics
- */
-declare function minimalPreset(options?: PresetOptions): ExpressMiddleware$1[];
-/**
- * Security preset - Maximum security headers
- */
-declare function securityPreset(options?: PresetOptions): ExpressMiddleware$1[];
-/**
- * Full-featured preset - Everything enabled for enterprise applications
- */
-declare function fullFeaturedPreset(options?: PresetOptions): ExpressMiddleware$1[];
-/**
- * Get preset by name with enhanced options and fallback support
+ * app.use(userRouter);
+ * ```
  */
-declare function getPreset(name: PresetName | string, options?: PresetOptions): ExpressMiddleware$1[];
+declare function createOptimizedRouter(prefix?: string, cacheSize?: number): OptimizedRouter;
 
 /**
- * 🔧 Built-in Middleware - NextRush Framework
+ * NextRush v2 - Main Entry Point
  *
- * Re-exports all built-in middleware from plugins for easy access.
- * This provides Express.js-like middleware functions that developers expect.
- */
-
-/**
- * Helmet Security Middleware
- * Sets various HTTP headers to secure your app
- */
-declare function helmet(options?: Record<string, any>): ExpressMiddleware$1;
-/**
- * Logger Middleware
- * Logs HTTP requests with timing
- */
-declare function logger(options?: {
-    format?: 'simple' | 'detailed' | 'json';
-}): ExpressMiddleware$1;
-/**
- * Request ID Middleware
- * Adds unique ID to each request
- */
-declare function requestId(options?: {
-    header?: string;
-}): ExpressMiddleware$1;
-/**
- * Request Timer Middleware - Optimized version
- * Adds response time header without memory leaks
- */
-declare function requestTimer(options?: {
-    header?: string;
-}): ExpressMiddleware$1;
-/**
- * Compression Middleware - Optimized version
- * Compresses response data efficiently
- */
-declare function compression(options?: {
-    level?: number;
-    threshold?: number;
-    filter?: (req: any, res: any) => boolean;
-}): ExpressMiddleware$1;
-/**
- * Rate Limiting Middleware - Optimized with cleanup
- * Limits requests per IP with automatic cleanup
- */
-declare function rateLimit(options?: {
-    windowMs?: number;
-    max?: number;
-    message?: string;
-    keyGenerator?: (req: any) => string;
-}): ExpressMiddleware$1;
-
-/**
- * 🚀 NextRush Framework - Modern/**
- * Plugin methods interface for proper TypeScript IntelliSense
- */
-interface PluginMethods {
-    listen(port: number | string, hostname?: string | (() => void), callback?: () => void): this;
-    close(callback?: () => void): this;
-    startServer(port: number | string, hostname?: string | (() => void), callback?: () => void): this;
-    shutdown(callback?: () => void): this;
-    usePreset(name: string, options?: any): this;
-    useGroup(middlewares: any[]): this;
-    cors(options?: any): any;
-    helmet(options?: any): any;
-    compression(options?: any): any;
-    rateLimit(options?: any): any;
-    logger(options?: any): any;
-    requestId(options?: any): any;
-    timer(options?: any): any;
-    compose(...middlewares: any[]): any;
-    when(condition: any, middleware: any): any;
-    unless(condition: any, middleware: any): any;
-    getPlugin(name: string): any;
-    getMiddlewareMetrics(): any;
-    clearMiddlewareMetrics(): void;
-    ws?(path: string, handler: any): this;
-    enableWebSocket?(options?: any): this;
-    wsBroadcast?(data: any, room?: string): this;
-    getWebSocketStats?(): any;
-    getWebSocketConnections?(): any;
-}
-/**
- * Extended Application type with all plugin methods for proper TypeScript IntelliSense
- */
-type ExtendedApplication = Application & PluginMethods;
-
-/**
- * Create a new NextRush application with full type safety
+ * @packageDocumentation
  */
-declare function createApp(options?: ApplicationOptions): ExtendedApplication;
 
-/**
- * Create a new router instance
- */
-declare function createRouter(options?: RouterOptions): Router;
+declare const VERSION = "2.0.0-alpha.1";
+declare const NODE_VERSION = ">=18.0.0";
 
-declare module './core/app/application' {
-    interface Application {
-        /**
-         * Start the server - backward compatibility
-         * @param port Port number or string
-         * @param hostname Optional hostname or callback
-         * @param callback Optional callback
-         * @returns Application instance
-         */
-        listen(port: number | string, hostname?: string | (() => void), callback?: () => void): Application;
-        /**
-         * Close the server - backward compatibility
-         * @param callback Optional callback
-         * @returns Application instance
-         */
-        close(callback?: () => void): Application;
-        /**
-         * Start the server - new method
-         * @param port Port number or string
-         * @param hostname Optional hostname or callback
-         * @param callback Optional callback
-         * @returns Application instance
-         */
-        startServer(port: number | string, hostname?: string | (() => void), callback?: () => void): Application;
-        /**
-         * Stop the server - new method
-         * @param callback Optional callback
-         * @returns Application instance
-         */
-        shutdown(callback?: () => void): Application;
-    }
-}
+declare const _default: {
+    readonly createApp: typeof createApp;
+    readonly VERSION: "2.0.0-alpha.1";
+    readonly NODE_VERSION: ">=18.0.0";
+};
 
-export { Application, type ApplicationOptions, type AsyncMiddleware, BaseComponent, type BodyParserOptions, BodyParserPlugin, CommonRoles, type CompileResult, type CorsOptions, CorsPresets, type CustomMetric, ErrorHandler, type ErrorMiddleware, type ErrorRequestHandler, EventDrivenPlugin, type ExpressHandler$1 as ExpressHandler, type ExpressMiddleware$1 as ExpressMiddleware, type ExtendedApplication, type FilterRegistry, type HealthCheckFunction, type HealthCheckResult, type HealthStatus, type HelperRegistry, type HttpMethod, type I18nConfig, InternalServerError, type JwtOptions, type Lifecycle, MethodNotAllowedError, type MetricValue, type MetricsOptions, type Middleware, type MiddlewareHandler$1 as MiddlewareHandler, type NextFunction, NextRushError, type NextRushRequest, type NextRushResponse, NotFoundError, type ParseResult, type ParsedRequest, type ParsedResponse, type Path, type Permission, type PluginMethods, PluginMode, type RateLimiterData, type RateLimiterOptions, type RateLimiterStore, type RenderOptions, type RequestContext, type RequestHandler, type RequestMetrics, type Role, type Route, type RouteDefinition, type RouteHandler$1 as RouteHandler, Router, type RouterOptions, type SanitizationOptions, type SessionOptions, type SimpleTemplateOptions, StaticFilesPlugin, type StaticOptions, type SystemMetrics, type TemplateContext, TemplateHelperManager, type TemplateNode, type TemplateOptions, type TestRenderResult, UltimateTemplateParser, UltimateTemplateRenderer, type User, ValidationError, ValidationPlugin, type ValidationResult, type ValidationRule, type ValidationSchema, advancedTemplate, apiPreset, benchmarkTemplate, compareTemplateEngines, compose, compression, createApp, createPlugins, createRouter, createSlotMap, createTemplate, Application as default, developmentPreset, escapeHTML, evaluateCondition, fullFeaturedPreset, getPreset, getValue, group, helmet, logger, minimalPreset, named, parseFrontmatter, productionPreset, quickTemplate, rateLimit, requestId, requestTimer, resolveTemplatePath, securityPreset, testTemplateRender, unless, validateTemplateSyntax, webTemplate, when };
+export { type Application, AuthenticationError, AuthenticationExceptionFilter, AuthorizationError, AuthorizationExceptionFilter, BadRequestError, ConflictError, ConsoleTransport, type Context, DatabaseError, type DotfilesPolicy, ErrorFactory, type ExceptionFilter, FileTransport, ForbiddenError, GlobalExceptionFilter, HttpTransport, InternalServerError, type LogEntry, LogLevel, type LoggerConfig, LoggerPlugin, MethodNotAllowedError, type Middleware, NODE_VERSION, NetworkError, type Next, NextRushError, type NextRushRequest, type NextRushResponse$1 as NextRushResponse, NotFoundError, NotFoundExceptionFilter, RateLimitError, RateLimitExceptionFilter, RequestEnhancer, ResponseEnhancer, type RouteConfig, type RouteHandler, type Router, ServiceUnavailableError, type StaticFilesOptions, StaticFilesPlugin, type StatsLike, StreamTransport, type TemplateHelper, TemplatePlugin, type TemplatePluginOptions, type TemplateRenderOptions, TimeoutError, TooManyRequestsError, type Transport, UnauthorizedError, UnprocessableEntityError, VERSION, ValidationError, ValidationExceptionFilter, type WSConnection, type WSContext, type WSHandler, type WSMiddleware, type WebSocketApplication, WebSocketPlugin, type WebSocketPluginOptions, smartBodyParser as bodyParser, compression, cors, createApp, createContext, createDevLogger, createMinimalLogger, createProdLogger, createOptimizedRouter as createRouter, _default as default, hasWebSocketSupport, helmet, logger, rateLimit, requestId, timer, withWebSocket };