nextrush 2.0.0 → 2.0.1

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { IncomingMessage, ServerResponse } from 'node:http';
+import * as http from 'http';
+import { IncomingMessage, ServerResponse, Server } from 'node:http';
 import { ParsedUrlQuery } from 'node:querystring';
 import { EventEmitter } from 'node:events';
 
@@ -628,12 +629,6 @@ interface NextRushResponse$1 extends ServerResponse {
     lastModified(date: Date): NextRushResponse$1;
 }
 
-/**
- * Koa-style context types for NextRush v2
- *
- * @packageDocumentation
- */
-
 /**
  * WebSocket connection interface
  */
@@ -1030,7 +1025,7 @@ interface Application {
     listen(port?: number, callback?: () => void): unknown;
     listen(port?: number, host?: string, callback?: () => void): unknown;
     /** Get the underlying HTTP server */
-    getServer(): unknown;
+    getServer(): http.Server;
     /** Gracefully shutdown the application */
     shutdown(): Promise<void>;
     /** Create CORS middleware */
@@ -1478,12 +1473,745 @@ declare class StreamTransport implements Transport {
     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
  *
@@ -2313,4 +3041,4 @@ declare const _default: {
     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, 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 };
+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 };