nextrush 1.5.0 → 2.0.1

package/dist/index.d.mts

@@ -0,0 +1,3044 @@
+import * as http from 'http';
+import { IncomingMessage, ServerResponse, Server } from 'node:http';
+import { ParsedUrlQuery } from 'node:querystring';
+import { EventEmitter } from 'node:events';
+
+/**
+ * Custom error classes for NextRush v2
+ *
+ * @packageDocumentation
+ */
+/**
+ * Base error class for NextRush v2
+ */
+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);
+    /**
+     * Create error from HTTP status code
+     */
+    static fromStatusCode(statusCode: number, message?: string): NextRushError;
+    /**
+     * Get error code from status code
+     */
+    private static getErrorCode;
+    /**
+     * Convert error to JSON
+     */
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Bad Request Error (400)
+ */
+declare class BadRequestError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Unauthorized Error (401)
+ */
+declare class UnauthorizedError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Forbidden Error (403)
+ */
+declare class ForbiddenError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Not Found Error (404)
+ */
+declare class NotFoundError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Method Not Allowed Error (405)
+ */
+declare class MethodNotAllowedError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Conflict Error (409)
+ */
+declare class ConflictError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Unprocessable Entity Error (422)
+ */
+declare class UnprocessableEntityError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Too Many Requests Error (429)
+ */
+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);
+    /**
+     * Create validation error for specific field
+     */
+    static forField(field: string, message: string, value?: unknown): ValidationError;
+    /**
+     * Create validation error for multiple fields
+     */
+    static forFields(errors: Array<{
+        field: string;
+        message: string;
+        value?: unknown;
+    }>): ValidationError;
+}
+/**
+ * Authentication Error (401)
+ */
+declare class AuthenticationError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Authorization Error (403)
+ */
+declare class AuthorizationError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Database Error (500)
+ */
+declare class DatabaseError extends NextRushError {
+    readonly operation: string;
+    readonly table: string | undefined;
+    constructor(message: string, operation?: string, table?: string, statusCode?: number);
+}
+/**
+ * Network Error (502)
+ */
+declare class NetworkError extends NextRushError {
+    readonly host: string;
+    readonly port: number;
+    constructor(message: string, host: string, port: number);
+}
+/**
+ * Timeout Error (408)
+ */
+declare class TimeoutError extends NextRushError {
+    constructor(message?: string);
+}
+/**
+ * Rate Limit Error (429)
+ */
+declare class RateLimitError extends NextRushError {
+    readonly retryAfter: number;
+    constructor(message?: string, retryAfter?: number);
+}
+/**
+ * Error Factory for creating common errors
+ */
+declare class ErrorFactory {
+    /**
+     * Create validation error
+     */
+    static validation(field: string, message: string, value?: unknown): ValidationError;
+    /**
+     * Create not found error
+     */
+    static notFound(resource: string): NotFoundError;
+    /**
+     * Create unauthorized error
+     */
+    static unauthorized(message?: string): AuthenticationError;
+    /**
+     * Create forbidden error
+     */
+    static forbidden(message?: string): AuthorizationError;
+    /**
+     * Create bad request error
+     */
+    static badRequest(message?: string): BadRequestError;
+    /**
+     * Create conflict error
+     */
+    static conflict(message?: string): ConflictError;
+    /**
+     * Create internal server error
+     */
+    static internal(message?: string): InternalServerError;
+    /**
+     * Create rate limit error
+     */
+    static rateLimit(message?: string, retryAfter?: number): RateLimitError;
+    /**
+     * Create timeout error
+     */
+    static timeout(message?: string): TimeoutError;
+    /**
+     * Create service unavailable error
+     */
+    static serviceUnavailable(message?: string): ServiceUnavailableError;
+    /**
+     * Create database error
+     */
+    static database(message: string, operation: string, table?: string): DatabaseError;
+    /**
+     * Create network error
+     */
+    static network(message: string, host: string, port: number): NetworkError;
+}
+/**
+ * Exception Filter Interface (NestJS style)
+ */
+interface ExceptionFilter {
+    catch(error: Error, ctx: any): void | Promise<void>;
+}
+/**
+ * Global Exception Filter
+ */
+declare class GlobalExceptionFilter implements ExceptionFilter {
+    catch(error: Error, ctx: any): Promise<void>;
+}
+/**
+ * Exception Filter for specific error types
+ */
+declare class ValidationExceptionFilter implements ExceptionFilter {
+    catch(error: Error, ctx: any): Promise<void>;
+}
+/**
+ * Exception Filter for authentication errors
+ */
+declare class AuthenticationExceptionFilter implements ExceptionFilter {
+    catch(error: Error, ctx: any): Promise<void>;
+}
+/**
+ * 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>;
+}
+
+/**
+ * 🔧 Enhanced parser configuration with enterprise-grade settings
+ */
+interface EnhancedBodyParserOptions {
+    /** Maximum body size in bytes (default: 10MB) */
+    maxSize?: number;
+    /** Request timeout in milliseconds (default: 5s) */
+    timeout?: number;
+    /** Enable streaming for large payloads (default: true) */
+    enableStreaming?: boolean;
+    /** Streaming threshold in bytes (default: 50MB) */
+    streamingThreshold?: number;
+    /** Buffer pool size for optimization (default: 100) */
+    poolSize?: number;
+    /** Enable fast validation (default: true) */
+    fastValidation?: boolean;
+    /** Auto-detect content type (default: true) */
+    autoDetectContentType?: boolean;
+    /** Strict content type checking (default: false) */
+    strictContentType?: boolean;
+    /** 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;
+    };
+}
+
+/**
+ * Middleware Types for NextRush v2
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * 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;
+}
+
+/**
+ * Cookie options interface with security defaults
+ */
+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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * WebSocket connection interface
+ */
+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;
+}
+/**
+ * Enhanced response object with Express-like methods
+ */
+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;
+}
+/**
+ * Koa-style context interface
+ */
+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;
+}
+/**
+ * Next function for middleware
+ */
+type Next = () => Promise<void>;
+/**
+ * Middleware function type
+ */
+type Middleware = (ctx: Context, next: Next) => Promise<void>;
+/**
+ * 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;
+}
+/**
+ * Route configuration object (Fastify-style)
+ */
+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;
+        };
+    };
+}
+/**
+ * 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(): http.Server;
+    /** 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
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Plugin interface
+ */
+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;
+    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;
+    /**
+     * Abstract method that plugins must implement
+     */
+    /**
+     * Get plugin metadata
+     */
+    getMetadata(): PluginMetadata;
+    /**
+     * Set plugin configuration
+     */
+    setConfig(config: Record<string, unknown>): void;
+    /**
+     * Get plugin configuration
+     */
+    getConfig(): Record<string, unknown>;
+    /**
+     * Get a specific configuration value
+     */
+    getConfigValue<T>(key: string, defaultValue?: T): T | undefined;
+    /**
+     * Check if plugin is installed
+     */
+    isPluginInstalled(): boolean;
+    /**
+     * Check if plugin is initialized
+     */
+    isPluginInitialized(): boolean;
+    /**
+     * Register middleware with the application
+     */
+    protected registerMiddleware(middleware: Middleware): void;
+    /**
+     * Log plugin message
+     */
+    protected log(message: string): void;
+    /**
+     * Log plugin error
+     */
+    protected logError(message: string, error?: Error): void;
+    /**
+     * Log plugin warning
+     */
+    protected logWarning(message: string): void;
+    /**
+     * Log plugin debug message
+     */
+    protected logDebug(message: string): void;
+    /**
+     * Emit plugin event
+     */
+    protected emit(event: string, ...args: unknown[]): void;
+    /**
+     * Create a middleware that wraps the plugin's functionality
+     */
+    protected createMiddleware(handler: (ctx: Context, next: () => Promise<void>) => void | Promise<void>): Middleware;
+    /**
+     * Create an async middleware that wraps the plugin's functionality
+     */
+    protected createAsyncMiddleware(handler: (ctx: Context, next: () => Promise<void>) => Promise<void>): Middleware;
+    /**
+     * Validate plugin configuration
+     */
+    validateConfig(): boolean;
+    /**
+     * Plugin health check
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Get plugin status
+     */
+    getStatus(): Record<string, unknown>;
+}
+
+/**
+ * Logger Types and Interfaces for NextRush v2
+ *
+ * @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>;
+}
+
+/**
+ * Core Logger Plugin for NextRush v2
+ *
+ * @packageDocumentation
+ */
+
+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;
+    /**
+     * Add a transport
+     */
+    addTransport(transport: Transport): void;
+    /**
+     * Remove a transport by name
+     */
+    removeTransport(name: string): void;
+    /**
+     * Add event listener
+     */
+    on(event: string, listener: (entry: LogEntry) => void): void;
+    /**
+     * Remove event listener
+     */
+    off(event: string, listener: (entry: LogEntry) => void): void;
+    /**
+     * Log a message (internal method for testing)
+     */
+    logMessage(level: LogLevel | string, message: string, context?: Record<string, unknown>): void;
+    /**
+     * Get transports (for testing)
+     */
+    getTransports(): Transport[];
+    /**
+     * Get transports property (for testing)
+     */
+    get transports(): Transport[];
+    cleanup(): void;
+}
+
+/**
+ * Logger Factory Functions for NextRush v2
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Create minimal logger for testing
+ */
+declare function createMinimalLogger(): LoggerPlugin;
+/**
+ * Create development logger
+ */
+declare function createDevLogger(): LoggerPlugin;
+/**
+ * Create production logger
+ */
+declare function createProdLogger(): LoggerPlugin;
+
+/**
+ * Logger Transport implementations for NextRush v2
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Console Transport
+ */
+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;
+}
+/**
+ * File Transport
+ */
+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>;
+}
+/**
+ * HTTP Transport
+ */
+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>;
+}
+/**
+ * Stream Transport
+ */
+declare class StreamTransport implements Transport {
+    name: string;
+    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;
+}
+
+/**
+ * NextRush v2 Event System Types
+ *
+ * Comprehensive type-safe event system with CQRS patterns,
+ * event sourcing, and pipeline processing capabilities.
+ *
+ * @version 2.0.0
+ * @author NextRush Core Team
+ */
+
+/**
+ * Base metadata for all events
+ */
+interface BaseEventMetadata {
+    /** Unique event ID */
+    readonly id: string;
+    /** Event timestamp in milliseconds */
+    readonly timestamp: number;
+    /** Event correlation ID for tracing */
+    readonly correlationId?: string;
+    /** User/system that triggered the event */
+    readonly source: string;
+    /** Event version for evolution */
+    readonly version: number;
+    /** Additional custom metadata */
+    readonly [key: string]: unknown;
+}
+/**
+ * Generic Event interface with full type safety
+ *
+ * @template TType - Event type identifier
+ * @template TData - Event payload data
+ * @template TMetadata - Additional event metadata
+ */
+interface Event<TType extends string = string, TData = unknown, TMetadata extends BaseEventMetadata = BaseEventMetadata> {
+    /** Event type identifier */
+    readonly type: TType;
+    /** Event payload data */
+    readonly data: TData;
+    /** Event metadata */
+    readonly metadata: TMetadata;
+}
+/**
+ * Command interface for CQRS pattern
+ * Commands represent intent to change state
+ */
+interface Command<TType extends string = string, TData = unknown, TMetadata extends BaseEventMetadata = BaseEventMetadata> extends Event<TType, TData, TMetadata> {
+    /** Command should be processed exactly once */
+    readonly idempotencyKey?: string;
+    /** Command execution timeout in milliseconds */
+    readonly timeout?: number;
+}
+/**
+ * Query interface for CQRS pattern
+ * Queries represent intent to read state
+ */
+interface Query<TType extends string = string, TData = unknown, TResult = unknown, TMetadata extends BaseEventMetadata = BaseEventMetadata> extends Event<TType, TData, TMetadata> {
+    /** Expected result type (for type inference) */
+    readonly _resultType?: TResult;
+}
+/**
+ * Domain Event for business logic events
+ */
+interface DomainEvent<TType extends string = string, TData = unknown, TMetadata extends BaseEventMetadata = BaseEventMetadata> extends Event<TType, TData, TMetadata> {
+    /** Aggregate ID that produced this event */
+    readonly aggregateId: string;
+    /** Aggregate type */
+    readonly aggregateType: string;
+    /** Event sequence number for ordering */
+    readonly sequenceNumber: number;
+}
+/**
+ * Event handler function type
+ */
+type EventHandler<T extends Event = Event> = (event: T, context?: Context) => Promise<void> | void;
+/**
+ * Event handler with metadata
+ */
+interface EventHandlerDefinition<T extends Event = Event> {
+    /** Handler function */
+    readonly handler: EventHandler<T>;
+    /** Handler priority (lower = higher priority) */
+    readonly priority?: number;
+    /** Handler should run only once */
+    readonly once?: boolean;
+    /** Handler timeout in milliseconds */
+    readonly timeout?: number;
+    /** Handler retry configuration */
+    readonly retry?: {
+        readonly maxAttempts: number;
+        readonly delay: number;
+        readonly backoffMultiplier?: number;
+    };
+}
+/**
+ * Event pipeline middleware function
+ */
+type EventPipelineMiddleware<T extends Event = Event> = (event: T, next: () => Promise<void>) => Promise<void> | void;
+/**
+ * Event transformer function
+ */
+type EventTransformer<TInput extends Event, TOutput extends Event> = (event: TInput) => Promise<TOutput> | TOutput;
+/**
+ * Event filter predicate
+ */
+type EventFilter<T extends Event = Event> = (event: T) => boolean | Promise<boolean>;
+/**
+ * Event pipeline stage
+ */
+interface EventPipelineStage<T extends Event = Event> {
+    /** Stage name */
+    readonly name: string;
+    /** Stage middleware */
+    readonly middleware?: EventPipelineMiddleware<T>[];
+    /** Event transformers */
+    readonly transformers?: EventTransformer<T, T>[];
+    /** Event filters */
+    readonly filters?: EventFilter<T>[];
+    /** Stage timeout in milliseconds */
+    readonly timeout?: number;
+}
+/**
+ * Event pipeline configuration
+ */
+interface EventPipelineConfig<T extends Event = Event> {
+    /** Pipeline name */
+    readonly name: string;
+    /** Pipeline stages */
+    readonly stages: EventPipelineStage<T>[];
+    /** Error handling strategy */
+    readonly errorHandling?: 'stop' | 'continue' | 'retry';
+    /** Pipeline timeout in milliseconds */
+    readonly timeout?: number;
+    /** Enable performance monitoring */
+    readonly monitoring?: boolean;
+}
+/**
+ * Event subscription handle
+ */
+interface EventSubscription {
+    /** Subscription ID */
+    readonly id: string;
+    /** Unsubscribe from events */
+    unsubscribe(): Promise<void>;
+    /** Check if subscription is active */
+    isActive(): boolean;
+}
+/**
+ * Event store statistics
+ */
+interface EventStoreStats {
+    /** Total events stored */
+    readonly totalEvents: number;
+    /** Events by type */
+    readonly eventsByType: Record<string, number>;
+    /** Storage size in bytes */
+    readonly storageSize: number;
+    /** Last event timestamp */
+    readonly lastEventTimestamp?: number;
+}
+/**
+ * Event processing metrics
+ */
+interface EventMetrics {
+    /** Events emitted by type */
+    readonly eventsEmitted: Record<string, number>;
+    /** Events processed by type */
+    readonly eventsProcessed: Record<string, number>;
+    /** Processing errors by type */
+    readonly processingErrors: Record<string, number>;
+    /** Average processing time by type (ms) */
+    readonly averageProcessingTime: Record<string, number>;
+    /** Pipeline execution stats */
+    readonly pipelineStats: Record<string, PipelineStats>;
+    /** Memory usage stats */
+    readonly memoryUsage: {
+        readonly heapUsed: number;
+        readonly heapTotal: number;
+        readonly external: number;
+    };
+}
+/**
+ * Pipeline execution statistics
+ */
+interface PipelineStats {
+    /** Pipeline executions count */
+    readonly executions: number;
+    /** Average execution time (ms) */
+    readonly averageExecutionTime: number;
+    /** Successful executions */
+    readonly successes: number;
+    /** Failed executions */
+    readonly failures: number;
+    /** Stage execution stats */
+    readonly stageStats: Record<string, {
+        readonly executions: number;
+        readonly averageTime: number;
+        readonly failures: number;
+    }>;
+}
+
+/**
+ * Command handler type
+ */
+type CommandHandler<TCommand extends Command, TResult = void> = (command: TCommand) => Promise<TResult> | TResult;
+/**
+ * Query handler type
+ */
+type QueryHandler<TQuery extends Query, TResult = unknown> = (query: TQuery) => Promise<TResult> | TResult;
+/**
+ * Event system configuration
+ */
+interface EventSystemConfig {
+    /** Enable event store persistence */
+    readonly enableEventStore?: boolean;
+    /** Event store type */
+    readonly eventStoreType?: 'memory' | 'persistent';
+    /** Maximum events for in-memory store */
+    readonly maxStoredEvents?: number;
+    /** Enable performance monitoring */
+    readonly enableMonitoring?: boolean;
+    /** Default event handler timeout */
+    readonly defaultTimeout?: number;
+    /** Maximum concurrent event processing */
+    readonly maxConcurrency?: number;
+}
+/**
+ * Complete event system with CQRS and Event Sourcing
+ */
+declare class NextRushEventSystem {
+    private readonly eventEmitter;
+    private readonly eventStore?;
+    private readonly commandHandlers;
+    private readonly queryHandlers;
+    private readonly config;
+    private systemSubscriptions;
+    constructor(config?: EventSystemConfig);
+    /**
+     * Emit an event
+     */
+    emit<T extends Event>(event: T): Promise<void>;
+    /**
+     * Create and emit an event
+     */
+    emitEvent<T extends Event>(type: T['type'], data: T['data'], metadata?: Partial<BaseEventMetadata>): Promise<void>;
+    /**
+     * Create and emit a domain event
+     */
+    emitDomainEvent<T extends DomainEvent>(type: T['type'], data: T['data'], aggregateId: string, aggregateType: string, sequenceNumber: number, metadata?: Partial<BaseEventMetadata>): Promise<void>;
+    /**
+     * Subscribe to events
+     */
+    subscribe<T extends Event>(eventType: string, handler: EventHandler<T>): EventSubscription;
+    /**
+     * Subscribe with options
+     */
+    subscribeWithOptions<T extends Event>(eventType: string, definition: EventHandlerDefinition<T>): EventSubscription;
+    /**
+     * Unsubscribe from events
+     */
+    unsubscribeAll(eventType: string): Promise<void>;
+    /**
+     * Add event pipeline
+     */
+    addPipeline<T extends Event>(eventType: string, pipeline: EventPipelineConfig<T>): void;
+    /**
+     * Remove event pipeline
+     */
+    removePipeline(eventType: string, pipelineName: string): void;
+    /**
+     * Get pipeline names
+     */
+    getPipelineNames(eventType: string): string[];
+    /**
+     * Register command handler
+     */
+    registerCommandHandler<TCommand extends Command, TResult = void>(commandType: string, handler: CommandHandler<TCommand, TResult>): void;
+    /**
+     * Execute command
+     */
+    executeCommand<TCommand extends Command, TResult = void>(command: TCommand): Promise<TResult>;
+    /**
+     * Register query handler
+     */
+    registerQueryHandler<TQuery extends Query, TResult = unknown>(queryType: string, handler: QueryHandler<TQuery, TResult>): void;
+    /**
+     * Execute query
+     */
+    executeQuery<TQuery extends Query, TResult = unknown>(query: TQuery): Promise<TResult>;
+    /**
+     * Load events for aggregate
+     */
+    loadAggregateEvents<T extends DomainEvent>(aggregateId: string, options?: {
+        readonly afterSequence?: number;
+        readonly limit?: number;
+    }): Promise<T[]>;
+    /**
+     * Load events by correlation ID
+     */
+    loadCorrelatedEvents<T extends Event>(correlationId: string, options?: {
+        readonly limit?: number;
+        readonly offset?: number;
+    }): Promise<T[]>;
+    /**
+     * Load events by type
+     */
+    loadEventsByType<T extends Event>(eventType: string, options?: {
+        readonly after?: Date;
+        readonly before?: Date;
+        readonly limit?: number;
+        readonly offset?: number;
+    }): Promise<T[]>;
+    /**
+     * Get event metrics
+     */
+    getMetrics(): EventMetrics;
+    /**
+     * Get event store statistics
+     */
+    getEventStoreStats(): Promise<EventStoreStats>;
+    /**
+     * Get subscription count
+     */
+    getSubscriptionCount(eventType?: string): number;
+    /**
+     * Enable/disable monitoring
+     */
+    setMonitoring(enabled: boolean): void;
+    /**
+     * Clear all events and subscriptions
+     */
+    clear(): Promise<void>;
+    /**
+     * Shutdown the event system
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Create event with metadata
+     */
+    createEvent<T extends Event>(type: T['type'], data: T['data'], metadata?: Partial<BaseEventMetadata>): T;
+    /**
+     * Create command with metadata
+     */
+    createCommand<T extends Command>(type: T['type'], data: T['data'], metadata?: Partial<BaseEventMetadata>): T;
+    /**
+     * Create query with metadata
+     */
+    createQuery<T extends Query>(type: T['type'], data: T['data'], metadata?: Partial<BaseEventMetadata>): T;
+    /**
+     * Create domain event with aggregate info
+     */
+    createDomainEvent<T extends DomainEvent>(type: T['type'], data: T['data'], aggregateId: string, aggregateType: string, sequenceNumber: number, metadata?: Partial<BaseEventMetadata>): T;
+    /**
+     * Emit system event
+     */
+    private emitSystemEvent;
+    /**
+     * Auto-persist events to store
+     */
+    private persistEventHandler;
+    /**
+     * Generic dispatch method for commands, queries, or events
+     * This provides a unified interface for different operation types
+     */
+    dispatch<T = any>(operation: Command | Query | Event): Promise<T>;
+}
+
+/**
+ * Simple Events API Facade for NextRush v2
+ *
+ * Provides a simple string-based event API that bridges to the sophisticated
+ * CQRS/Event Sourcing implementation underneath.
+ *
+ * @version 2.0.0
+ * @author NextRush Core Team
+ */
+
+/**
+ * Simple event handler type for string-based events
+ */
+type SimpleEventHandler = (data: any) => void | Promise<void>;
+/**
+ * Simple Events API Facade
+ *
+ * Provides familiar Express-style event API while leveraging
+ * the sophisticated CQRS implementation underneath.
+ */
+declare class SimpleEventsAPI {
+    private eventSystem;
+    private listeners;
+    constructor(eventSystem: NextRushEventSystem);
+    /**
+     * Emit a simple string-based event
+     *
+     * @param eventName - Event name
+     * @param data - Event data
+     * @returns Promise that resolves when event is processed
+     *
+     * @example
+     * ```typescript
+     * app.events.emit('user.created', { userId: '123', name: 'John' });
+     * ```
+     */
+    emit(eventName: string, data?: any): Promise<void>;
+    /**
+     * Listen for a simple string-based event
+     *
+     * @param eventName - Event name to listen for
+     * @param handler - Handler function
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = app.events.on('user.created', (data) => {
+     *   console.log('User created:', data.userId);
+     * });
+     * ```
+     */
+    on(eventName: string, handler: SimpleEventHandler): () => void;
+    /**
+     * Listen for a simple string-based event (once)
+     *
+     * @param eventName - Event name to listen for
+     * @param handler - Handler function
+     * @returns Promise that resolves with event data
+     *
+     * @example
+     * ```typescript
+     * const data = await app.events.once('user.created');
+     * console.log('User created:', data.userId);
+     * ```
+     */
+    once(eventName: string, handler?: SimpleEventHandler): Promise<any>;
+    /**
+     * Remove all listeners for an event
+     *
+     * @param eventName - Event name
+     *
+     * @example
+     * ```typescript
+     * app.events.off('user.created');
+     * ```
+     */
+    off(eventName: string): void;
+    /**
+     * Remove all listeners
+     *
+     * @example
+     * ```typescript
+     * app.events.removeAllListeners();
+     * ```
+     */
+    removeAllListeners(): void;
+    /**
+     * Get list of event names that have listeners
+     *
+     * @returns Array of event names
+     */
+    eventNames(): string[];
+    /**
+     * Get number of listeners for an event
+     *
+     * @param eventName - Event name
+     * @returns Number of listeners
+     */
+    listenerCount(eventName: string): number;
+    /**
+     * Get maximum number of listeners (for compatibility)
+     * Returns Infinity as we don't impose limits
+     */
+    getMaxListeners(): number;
+    /**
+     * Set maximum number of listeners (for compatibility)
+     * No-op as we don't impose limits
+     */
+    setMaxListeners(_n: number): this;
+}
+
+/**
+ * Core Application class for NextRush v2
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * NextRush Application class with Koa-style middleware and Express-like design
+ *
+ * @example
+ * ```typescript
+ * import { createApp } from 'nextrush-v2';
+ *
+ * const app = createApp({ port: 3000 });
+ *
+ * app.use(async (ctx, next) => {
+ *   console.log(`${ctx.method} ${ctx.path}`);
+ *   await next();
+ * });
+ *
+ * app.get('/hello', async (ctx) => {
+ *   ctx.res.json({ message: 'Hello, World!' });
+ * });
+ *
+ * app.listen(3000, () => {
+ *   console.log('Server running on http://localhost:3000');
+ * });
+ * ```
+ */
+declare class NextRushApplication extends EventEmitter implements Application {
+    private server;
+    private middleware;
+    private internalRouter;
+    private options;
+    private isShuttingDown;
+    private container;
+    private middlewareFactory;
+    private compiler;
+    private cachedExceptionFilter;
+    private static readonly EXCEPTION_FILTER_MARK;
+    private _eventSystem;
+    private _simpleEvents;
+    constructor(options?: ApplicationOptions);
+    /**
+     * Create HTTP server
+     */
+    private createServer;
+    /**
+     * Setup event handlers
+     */
+    private setupEventHandlers;
+    /**
+     * Get cached exception filter or scan once and cache it
+     */
+    private getOrFindExceptionFilter;
+    /**
+     * Handle incoming requests
+     */
+    private handleRequest;
+    /**
+     * Execute middleware stack.
+     * - Production: run directly on ctx for maximum performance.
+     * - Debug mode: wrap with SafeContext for diagnostics.
+     */
+    private executeMiddlewareWithBoundary;
+    /**
+     * Execute route handler with high-performance direct execution
+     */
+    private executeRouteWithBoundary;
+    /**
+     * Register GET route
+     */
+    get(path: string, handler: RouteHandler | RouteConfig): this;
+    /**
+     * Register POST route
+     */
+    post(path: string, handler: RouteHandler | RouteConfig): this;
+    /**
+     * Register PUT route
+     */
+    put(path: string, handler: RouteHandler | RouteConfig): this;
+    /**
+     * Register DELETE route
+     */
+    delete(path: string, handler: RouteHandler | RouteConfig): this;
+    /**
+     * Register PATCH route
+     */
+    patch(path: string, handler: RouteHandler | RouteConfig): this;
+    /**
+     * Register middleware or sub-router
+     */
+    use(middleware: Middleware): this;
+    use(prefix: string, router: Router): this;
+    /**
+     * Create router instance
+     */
+    router(): Router;
+    /**
+     * Register a route with the router
+     */
+    private registerRoute;
+    /**
+     * Start the server
+     */
+    listen(port?: number, callback?: () => void): Server;
+    listen(port?: number, host?: string, callback?: () => void): Server;
+    /**
+     * Get the underlying HTTP server
+     */
+    getServer(): Server;
+    /**
+     * Get simple events API for Express-style event handling
+     *
+     * @example
+     * ```typescript
+     * app.events.emit('user.created', { userId: '123' });
+     * app.events.on('user.created', (data) => console.log(data));
+     * ```
+     */
+    get events(): SimpleEventsAPI;
+    /**
+     * Get advanced event system for CQRS and Event Sourcing
+     *
+     * @example
+     * ```typescript
+     * app.eventSystem.dispatch(new CreateUserCommand({ name: 'John' }));
+     * app.eventSystem.subscribe(UserCreatedEvent, handler);
+     * ```
+     */
+    get eventSystem(): NextRushEventSystem;
+    /**
+     * Gracefully shutdown the application
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Create CORS middleware - now delegated to middleware factory
+     */
+    cors(options?: CorsOptions): Middleware;
+    /**
+     * Create helmet middleware - now delegated to middleware factory
+     */
+    helmet(options?: HelmetOptions): Middleware;
+    /**
+     * Create JSON body parser middleware - now delegated to middleware factory
+     */
+    json(options?: EnhancedBodyParserOptions): Middleware;
+    /**
+     * Create URL-encoded body parser middleware - now delegated to middleware factory
+     */
+    urlencoded(options?: EnhancedBodyParserOptions): Middleware;
+    /**
+     * Create text body parser middleware - now delegated to middleware factory
+     */
+    text(options?: EnhancedBodyParserOptions): Middleware;
+    /**
+     * Create rate limiter middleware - now delegated to middleware factory
+     */
+    rateLimit(options?: RateLimiterOptions): Middleware;
+    /**
+     * Create logger middleware - now delegated to middleware factory
+     */
+    logger(options?: LoggerOptions): Middleware;
+    /**
+     * Create compression middleware - now delegated to middleware factory
+     */
+    compression(options?: CompressionOptions): Middleware;
+    /**
+     * Create request ID middleware - now delegated to middleware factory
+     */
+    requestId(options?: RequestIdOptions): Middleware;
+    /**
+     * Create timer middleware - now delegated to middleware factory
+     */
+    timer(options?: TimerOptions): Middleware;
+    /**
+     * Create smart body parser middleware - now delegated to middleware factory
+     */
+    smartBodyParser(options?: EnhancedBodyParserOptions): Middleware;
+    /**
+     * Create exception filter middleware
+     *
+     * Provides NestJS-style exception handling with custom error classes
+     * and automatic error response formatting.
+     *
+     * @param filters - Array of exception filters to use
+     * @returns Exception filter middleware function
+     *
+     * @example
+     * ```typescript
+     * const app = createApp();
+     *
+     * // Global exception filter
+     * app.use(app.exceptionFilter());
+     *
+     * // With custom filters
+     * app.use(app.exceptionFilter([
+     *   new ValidationExceptionFilter(),
+     *   new AuthenticationExceptionFilter(),
+     *   new GlobalExceptionFilter()
+     * ]));
+     * ```
+     */
+    exceptionFilter(filters?: ExceptionFilter[]): Middleware;
+    /**
+     * Create advanced logger plugin
+     *
+     * Provides comprehensive logging capabilities similar to Winston/Pino
+     * with multiple transports, structured logging, and performance optimization.
+     *
+     * @param config - Logger configuration options
+     * @returns Logger plugin instance
+     *
+     * @example
+     * ```typescript
+     * const app = createApp();
+     *
+     * // Development logger
+     * const logger = app.createLogger({
+     *   level: 'debug',
+     *   requestLogging: true,
+     *   performance: true
+     * });
+     * logger.install(app);
+     *
+     * // Use logger in routes
+     * app.get('/users', ctx => {
+     *   app.logger.info('Fetching users', { userId: ctx.params.id });
+     *   ctx.res.json({ users: [] });
+     * });
+     * ```
+     */
+    createLogger(config?: {
+        level?: 'error' | 'warn' | 'info' | 'http' | 'verbose' | 'debug' | 'silly';
+        transports?: any[];
+        format?: 'json' | 'text' | 'combined';
+        colorize?: boolean;
+        timestamp?: boolean;
+        context?: string;
+        requestLogging?: boolean;
+        performance?: boolean;
+        structured?: boolean;
+    }): LoggerPlugin;
+    private convertLogLevel;
+    /**
+     * Create development logger
+     *
+     * Optimized for development with debug level, colors, and detailed logging.
+     *
+     * @returns Development logger plugin
+     */
+    createDevLogger(): LoggerPlugin;
+    /**
+     * Create production logger
+     *
+     * Optimized for production with info level, JSON format, and file logging.
+     *
+     * @returns Production logger plugin
+     */
+    createProdLogger(): LoggerPlugin;
+}
+/**
+ * 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');
+ * });
+ * ```
+ */
+declare function createApp(options?: ApplicationOptions): Application;
+
+/**
+ * Context factory for NextRush v2
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * 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' });
+ * ```
+ */
+declare function createContext(req: IncomingMessage | NextRushRequest, res: ServerResponse | NextRushResponse, _options: Required<ApplicationOptions>): Context;
+
+/**
+ * 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
+ */
+
+/**
+ * StaticFilesPlugin
+ */
+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;
+}
+
+/**
+ * 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;
+    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[];
+}
+
+/**
+ * WebSocket Plugin Type Augmentation
+ *
+ * This file provides type-safe WebSocket functionality through smart type casting
+ * and utility types for perfect TypeScript intelligence.
+ */
+
+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;
+
+/**
+ * WebSocket Plugin for NextRush v2 - Context-based Architecture
+ * Provides WebSocket functionality through context enhancement
+ */
+
+/**
+ * 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;
+}
+/**
+ * WebSocket Plugin for NextRush v2
+ *
+ * Enhances context with WebSocket functionality following v2 architecture patterns
+ */
+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;
+    /**
+     * Execute WebSocket middlewares
+     */
+    private executeMiddlewares;
+    /**
+     * Handle WebSocket upgrade in middleware context
+     */
+    private handleWebSocketUpgrade;
+    /**
+     * Verify WebSocket upgrade request
+     */
+    private verifyUpgrade;
+    /**
+     * Perform WebSocket handshake
+     */
+    private performHandshake;
+    /**
+     * Generate WebSocket accept key
+     */
+    private generateAcceptKey;
+    /**
+     * Check if request is WebSocket upgrade request
+     */
+    private isWebSocketRequest;
+    /**
+     * Check if path matches registered WebSocket routes
+     */
+    private matchPath;
+    /**
+     * Reject WebSocket connection
+     */
+    private rejectConnection;
+    /**
+     * Get all active connections
+     */
+    getConnections(): WSConnection[];
+    /**
+     * Broadcast message to all connections
+     */
+    broadcast(message: string, room?: string): void;
+    /**
+     * Get connection statistics
+     */
+    getStats(): {
+        totalConnections: number;
+        rooms: string[];
+        handlers: number;
+    };
+}
+
+/**
+ * 🚀 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 ✅
+ *
+ * @author NextRush Framework Team
+ * @version 2.0.0
+ */
+
+/**
+ * 🌍 Global smart parser instance (removed unused variable)
+ */
+/**
+ * 🚀 Create smart body parser middleware
+ */
+declare function smartBodyParser(options?: EnhancedBodyParserOptions): Middleware;
+
+/**
+ * Compression middleware for NextRush v2
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Compression middleware factory
+ */
+declare function compression(options?: CompressionOptions): Middleware;
+
+/**
+ * CORS Middleware for NextRush v2
+ *
+ * High-performance CORS implementation with pre-computed headers
+ * and optimized origin checking for enterprise applications.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * 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'],
+ * }));
+ * ```
+ */
+declare function cors(options?: CorsOptions): Middleware$1;
+
+/**
+ * Helmet Middleware for NextRush v2
+ *
+ * Provides security headers to protect against common vulnerabilities
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * 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'"],
+ *     },
+ *   },
+ * }));
+ * ```
+ */
+declare function helmet(options?: HelmetOptions): Middleware$1;
+
+/**
+ * Logger Middleware for NextRush v2
+ *
+ * Provides request logging functionality
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * 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,
+ * }));
+ * ```
+ */
+declare function logger(options?: LoggerOptions): Middleware$1;
+
+/**
+ * Rate Limiter Middleware for NextRush v2
+ *
+ * Provides rate limiting functionality to prevent abuse
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * 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'),
+ * }));
+ * ```
+ */
+declare function rateLimit(options?: RateLimiterOptions): Middleware$1;
+
+/**
+ * Request ID Middleware for NextRush v2
+ *
+ * Provides request ID generation and tracking functionality
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * 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,
+ * }));
+ * ```
+ */
+declare function requestId(options?: RequestIdOptions): Middleware$1;
+
+/**
+ * Timer middleware for NextRush v2
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * 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,
+ * }));
+ * ```
+ */
+declare function timer(options?: TimerOptions): Middleware$1;
+
+/**
+ * Request Enhancer for NextRush v2
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Enhanced request interface with Express-like properties and methods
+ */
+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;
+    };
+    timing(): {
+        start: number;
+        duration: number;
+        timestamp: 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;
+}
+/**
+ * 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
+ * ```
+ */
+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;
+}
+
+/**
+ * Response Enhancer for NextRush v2
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * File options interface
+ */
+interface FileOptions {
+    etag?: boolean;
+    root?: string;
+}
+/**
+ * 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;
+}
+/**
+ * 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 ResponseEnhancer {
+    /**
+     * Enhance a Node.js ServerResponse with NextRush v2 features
+     *
+     * @param res - The original HTTP response
+     * @returns Enhanced response with additional methods
+     */
+    static enhance(res: ServerResponse): EnhancedResponse;
+}
+
+/**
+ * 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
+ */
+
+/**
+ * Route match result with pre-allocated parameter object
+ */
+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);
+    /**
+     * Optimized parameter object management
+     */
+    private getParamObject;
+    /**
+     * Get pool statistics for monitoring
+     */
+    private getPoolStats;
+    /**
+     * Register a GET route
+     */
+    get(path: string, handler: RouteHandler | RouteConfig): OptimizedRouter;
+    /**
+     * Register a POST route
+     */
+    post(path: string, handler: RouteHandler | RouteConfig): OptimizedRouter;
+    /**
+     * Register a PUT route
+     */
+    put(path: string, handler: RouteHandler | RouteConfig): OptimizedRouter;
+    /**
+     * Register a DELETE route
+     */
+    delete(path: string, handler: RouteHandler | RouteConfig): OptimizedRouter;
+    /**
+     * Register a PATCH route
+     */
+    patch(path: string, handler: RouteHandler | RouteConfig): OptimizedRouter;
+    /**
+     * Use middleware or create sub-router
+     */
+    use(middlewareOrPrefix: string | Middleware, router?: Router): OptimizedRouter;
+    /**
+     * Get all registered routes for sub-router integration
+     */
+    getRoutes(): Map<string, RouteData>;
+    /**
+     * Get router middleware
+     */
+    getMiddleware(): Middleware[];
+    /**
+     * 🔥 Inject compiled handler for a route (used by compiler)
+     * This allows the pre-compilation system to inject optimized handlers
+     */
+    setCompiledHandler(method: string, pattern: string, compiledExecute: (ctx: any) => Promise<void>): void;
+    /**
+     * Get comprehensive cache and performance statistics
+     */
+    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;
+        };
+    };
+    /**
+     * Get total number of registered routes
+     */
+    private getTotalRoutes;
+    /**
+     * Clear the route cache
+     */
+    clearCache(): void;
+    /**
+     * Ultra-fast route finder with aggressive optimizations
+     */
+    find(method: string, path: string): OptimizedRouteMatch | null;
+    /**
+     * Hyper-optimized internal finder with minimal allocations
+     */
+    private findInternalOptimized;
+    /**
+     * Optimized route registration with O(k) insertion
+     */
+    private registerRoute;
+    /**
+     * Iteratively collect all routes from the tree (no recursion)
+     */
+    private collectRoutesIterative;
+}
+/**
+ * Create a new optimized router instance
+ *
+ * @param prefix - Optional route prefix
+ * @param cacheSize - Optional cache size (default: 1000)
+ * @returns OptimizedRouter instance
+ *
+ * @example
+ * ```typescript
+ * import { createOptimizedRouter } from 'nextrush-v2';
+ *
+ * const userRouter = createOptimizedRouter('/users', 2000);
+ *
+ * userRouter.get('/profile', async (ctx) => {
+ *   ctx.res.json({ user: 'profile' });
+ * });
+ *
+ * app.use(userRouter);
+ * ```
+ */
+declare function createOptimizedRouter(prefix?: string, cacheSize?: number): OptimizedRouter;
+
+/**
+ * NextRush v2 - Main Entry Point
+ *
+ * @packageDocumentation
+ */
+
+declare const VERSION = "2.0.0-alpha.1";
+declare const NODE_VERSION = ">=18.0.0";
+
+declare const _default: {
+    readonly createApp: typeof createApp;
+    readonly VERSION: "2.0.0-alpha.1";
+    readonly NODE_VERSION: ">=18.0.0";
+};
+
+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, NextRushApplication, 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 };