@stacksjs/bun-router 0.0.2 → 0.0.3

package/dist/file-serving/static-files.d.ts

@@ -1,98 +0,0 @@
-/**
- * Static file middleware factory
- */
-export declare function createStaticFileMiddleware(config: StaticFileConfig): void;
-/**
- * Static file serving helpers
- */
-export declare const StaticFileHelpers: {
-  /**
-   * Create development server with hot reload
-   */
-  createDevelopmentServer: (config: StaticFileConfig) => any;
-  /**
-   * Create production server with aggressive caching
-   */
-  createProductionServer: (config: StaticFileConfig) => any;
-  /**
-   * Create SPA server with fallback to index.html
-   */
-  createSPAServer: (config: StaticFileConfig) => any
-};
-/**
- * File serving utilities
- */
-export declare const FileServingUtils: {
-  /**
-   * Calculate optimal cache settings based on file type
-   */
-  getOptimalCacheSettings: (filePath: string) => any;
-  /**
-   * Generate security headers for static files
-   */
-  generateSecurityHeaders: () => unknown;
-  /**
-   * Create file watcher for cache invalidation
-   */
-  createFileWatcher: (server: StaticFileServer, watchPath: string) => Promise<{ close: ()
-};
-/**
- * Static File Serving
- *
- * Efficient file serving using Bun.file() with advanced caching and optimization
- */
-export declare interface StaticFileConfig {
-  root: string
-  maxAge?: number
-  immutable?: boolean
-  etag?: boolean
-  lastModified?: boolean
-  index?: string[]
-  extensions?: string[]
-  fallthrough?: boolean
-  setHeaders?: (res: Response, path: string, stat: any) => void
-  compression?: boolean
-  compressionThreshold?: number
-  cacheControl?: string
-  dotfiles?: 'allow' | 'deny' | 'ignore'
-}
-export declare interface FileCache {
-  content: ArrayBuffer
-  etag: string
-  lastModified: string
-  mimeType: string
-  size: number
-  compressed?: ArrayBuffer
-  compressedEtag?: string
-}
-export declare interface FileStats {
-  hits: number
-  misses: number
-  bytesServed: number
-  compressionRatio: number
-  averageResponseTime: number
-  lastAccessed: number
-}
-/**
- * High-performance static file server using Bun.file()
- */
-export declare class StaticFileServer {
-  private config: Required<StaticFileConfig>;
-  private cache: any;
-  private stats: any;
-  private compressionCache: any;
-  constructor(config: StaticFileConfig);
-  serve(request: Request): Promise<Response | null>;
-  serveFile(request: Request, filePath: string, requestPath: string): Promise<Response>;
-  private serveCachedFile(request: Request, cached: FileCache, requestPath: string, startTime: number): Response;
-  private resolveFile(pathname: string): Promise<string | null>;
-  private joinPath(parts: string[]): string;
-  private generateEtag(content: ArrayBuffer, lastModified: string): string;
-  private compressContent(content: ArrayBuffer): Promise<ArrayBuffer | null>;
-  private getMimeType(filePath: string): string;
-  private updateStats(path: string, bytes: number, startTime: number, cached: boolean): void;
-  getStats(): Record<string, FileStats>;
-  clearCache(): void;
-  getCacheSize(): number;
-  preloadFiles(paths: string[]): Promise<void>;
-}

package/dist/middleware/auth.d.ts

@@ -1,34 +0,0 @@
-import type { EnhancedRequest, Middleware, NextFunction } from '../types';
-/**
- * Extracts and decodes Basic Auth credentials from Authorization header
- */
-export declare function extractBasicAuth(authHeader: string): { username: string, password: string } | null;
-/**
- * Extracts Bearer token from Authorization header
- */
-export declare function extractBearerToken(authHeader: string): string | null;
-/**
- * Extracts API key from various sources
- */
-export declare function extractApiKey(req: EnhancedRequest, source?: 'header' | 'query' | 'cookie', key?: string): string | null;
-// Convenience factory functions for common auth types
-export declare function basicAuth(validator: (credentials: { username: string, password: string }, req: EnhancedRequest) => Promise<boolean> | boolean, options?: Partial<AuthOptions>): AuthMiddleware;
-export declare function bearerAuth(validator: (token: string, req: EnhancedRequest) => Promise<boolean> | boolean, options?: Partial<AuthOptions>): AuthMiddleware;
-export declare function jwtAuth(validator: (token: string, req: EnhancedRequest) => Promise<boolean> | boolean, options?: Partial<AuthOptions>): AuthMiddleware;
-export declare function apiKeyAuth(validator: (apiKey: string, req: EnhancedRequest) => Promise<boolean> | boolean, options?: Partial<AuthOptions>): AuthMiddleware;
-export declare function oauth2Auth(validator: (token: string, req: EnhancedRequest) => Promise<boolean> | boolean, options?: Partial<AuthOptions>): AuthMiddleware;
-export declare interface AuthOptions {
-  type: 'basic' | 'bearer' | 'api-key' | 'oauth2' | 'jwt' | 'custom'
-  validator: (credentials: any, req: EnhancedRequest) => Promise<boolean> | boolean
-  userExtractor?: (credentials: any, req: EnhancedRequest) => Promise<any> | any
-  source?: 'header' | 'query' | 'cookie'
-  key?: string
-  realm?: string
-  credentialsExtractor?: (req: EnhancedRequest) => Promise<any> | any
-  attachUser?: boolean
-}
-export declare class AuthMiddleware implements Middleware {
-  private options: AuthOptions;
-  constructor(options: AuthOptions);
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-}

package/dist/middleware/content_security_policy.d.ts

@@ -1,54 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-// Factory function for easy use
-export declare function contentSecurityPolicy(options?: CSPOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response>;
-export declare interface CSPDirectives {
-  'default-src'?: string[]
-  'script-src'?: string[]
-  'script-src-elem'?: string[]
-  'script-src-attr'?: string[]
-  'style-src'?: string[]
-  'style-src-elem'?: string[]
-  'style-src-attr'?: string[]
-  'img-src'?: string[]
-  'font-src'?: string[]
-  'connect-src'?: string[]
-  'media-src'?: string[]
-  'object-src'?: string[]
-  'child-src'?: string[]
-  'frame-src'?: string[]
-  'worker-src'?: string[]
-  'frame-ancestors'?: string[]
-  'form-action'?: string[]
-  'base-uri'?: string[]
-  'manifest-src'?: string[]
-  'prefetch-src'?: string[]
-  'navigate-to'?: string[]
-  'report-uri'?: string[]
-  'report-to'?: string[]
-  'require-trusted-types-for'?: string[]
-  'trusted-types'?: string[]
-  'upgrade-insecure-requests'?: boolean
-  'block-all-mixed-content'?: boolean
-  'plugin-types'?: string[]
-  'sandbox'?: string[]
-  'disown-opener'?: boolean
-}
-export declare interface CSPOptions {
-  directives?: CSPDirectives
-  reportOnly?: boolean
-  reportUri?: string
-  reportTo?: string
-  useNonces?: boolean
-  nonceLength?: number
-  upgradeInsecureRequests?: boolean
-  blockAllMixedContent?: boolean
-}
-export declare class ContentSecurityPolicy {
-  private options: CSPOptions;
-  private nonces: Map<string, string>;
-  constructor(options?: CSPOptions);
-  private generateNonce(): string;
-  private buildCSPHeader(): string;
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-  getNonce(url: string): string | undefined;
-}

package/dist/middleware/cors.d.ts

@@ -1,5 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-export declare class Cors {
-  private getCorsHeaders(): Record<string, string>;
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-}

package/dist/middleware/csrf.d.ts

@@ -1,7 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-export declare class Csrf {
-  static private tokens: any;
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-  private generateToken(secret: string): string;
-  private parseCookies(req: Request): Record<string, string>;
-}

package/dist/middleware/ddos_protection.d.ts

@@ -1,47 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-// Factory function for easy use
-export declare function ddosProtection(options?: DDoSProtectionOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response>;
-export declare interface DDoSProtectionOptions {
-  enabled?: boolean
-  maxRequestsPerSecond?: number
-  maxRequestsPerMinute?: number
-  maxRequestsPerHour?: number
-  burstLimit?: number
-  windowSize?: number
-  blockDuration?: number
-  whitelistedIPs?: string[]
-  blacklistedIPs?: string[]
-  trustProxy?: boolean
-  skipSuccessfulRequests?: boolean
-  skipFailedRequests?: boolean
-  keyGenerator?: (req: EnhancedRequest) => string
-  onLimitReached?: (req: EnhancedRequest, rateLimitInfo: any) => Response | Promise<Response>
-  store?: 'memory' | 'redis'
-  redis?: {
-    url: string
-    prefix?: string
-  }
-}
-declare interface RequestInfo {
-  count: number
-  firstRequest: number
-  lastRequest: number
-  blocked: boolean
-  blockExpires?: number
-}
-export declare class DDoSProtection {
-  private options: DDoSProtectionOptions;
-  private requestStore: Map<string, RequestInfo>;
-  private cleanupInterval: Timer | null;
-  constructor(options?: DDoSProtectionOptions);
-  private defaultKeyGenerator(req: EnhancedRequest): string;
-  private startCleanupInterval(): void;
-  private isWhitelisted(ip: string): boolean;
-  private isBlacklisted(ip: string): boolean;
-  private getRateLimitInfo(key: string, now: number): RequestInfo;
-  private shouldBlock(info: RequestInfo, now: number): boolean;
-  private blockIP(info: RequestInfo, now: number): void;
-  private createBlockedResponse(req: EnhancedRequest, info: RequestInfo): Response;
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-  destroy(): void;
-}

package/dist/middleware/file_security.d.ts

@@ -1,23 +0,0 @@
-import type { UploadedFile } from './file_upload';
-export declare function createFileSecurity(config?: FileSecurityConfig): FileSecurity;
-export declare interface FileSecurityConfig {
-  scanForMalware?: boolean
-  checkMagicNumbers?: boolean
-  sanitizeFilenames?: boolean
-  preventExecutableUploads?: boolean
-  maxFilenameLength?: number
-}
-export declare class FileSecurity {
-  private config: Required<FileSecurityConfig>;
-  readonly private FILE_SIGNATURES: Record<string, Uint8Array[]>;
-  readonly private EXECUTABLE_EXTENSIONS: any;
-  constructor(config?: FileSecurityConfig);
-  validateFile(file: UploadedFile): { isValid: boolean, errors: string[] };
-  private validateFileSignature(file: UploadedFile): boolean;
-  private sanitizeFilename(filename: string): string;
-  private getFileExtension(filename: string): string;
-  private basicMalwareScan(file: UploadedFile): boolean;
-  getSafeFilename(originalName: string): string;
-  isAllowedFileType(mimetype: string, allowedTypes: string[]): boolean;
-  isWithinSizeLimit(fileSize: number, maxSize: number): boolean;
-}

package/dist/middleware/file_upload.d.ts

@@ -1,41 +0,0 @@
-import FileSecurity from './file_security';
-import type { EnhancedRequest, NextFunction } from '../types';
-import type { FileSecurityConfig } from './file_security';
-// Factory function for easier usage
-export declare function fileUpload(config?: FileUploadConfig): FileUpload;
-// Specialized factory functions
-export declare function singleFileUpload(fieldName: string, config?: FileUploadConfig): FileUpload;
-export declare function multipleFileUpload(maxFiles?: number, config?: FileUploadConfig): FileUpload;
-export declare function imageUpload(config?: FileUploadConfig): FileUpload;
-export declare function documentUpload(config?: FileUploadConfig): FileUpload;
-export declare interface UploadedFile {
-  fieldName: string
-  originalName: string
-  filename: string
-  path: string
-  size: number
-  mimetype: string
-  buffer: ArrayBuffer
-}
-export declare interface FileUploadConfig extends FileSecurityConfig {
-  destination?: string
-  maxFileSize?: number
-  maxFiles?: number
-  allowedMimeTypes?: string[]
-  allowedExtensions?: string[]
-  preserveOriginalName?: boolean
-  generateUniqueFilename?: boolean
-  createDestination?: boolean
-}
-export declare interface FileUploadOptions extends FileUploadConfig {
-  fieldName?: string | string[]
-}
-export declare class FileUpload {
-  private config: Required<FileUploadConfig>;
-  private fileSecurity: FileSecurity;
-  constructor(config?: FileUploadConfig);
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-  private generateFilename(originalName: string): string;
-  private formatBytes(bytes: number): string;
-  private createErrorResponse(message: string, status: number): Response;
-}

package/dist/middleware/helmet.d.ts

@@ -1,54 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-export declare interface HelmetOptions {
-  contentSecurityPolicy?: boolean | {
-    directives?: Record<string, string[]>
-    reportOnly?: boolean
-    reportUri?: string
-    upgradeInsecureRequests?: boolean
-    blockAllMixedContent?: boolean
-  }
-  crossOriginEmbedderPolicy?: boolean | {
-    policy?: 'require-corp' | 'credentialless'
-  }
-  crossOriginOpenerPolicy?: boolean | {
-    policy?: 'same-origin' | 'same-origin-allow-popups' | 'unsafe-none'
-  }
-  crossOriginResourcePolicy?: boolean | {
-    policy?: 'same-site' | 'same-origin' | 'cross-origin'
-  }
-  dnsPrefetchControl?: boolean | {
-    allow?: boolean
-  }
-  expectCt?: boolean | {
-    enforce?: boolean
-    maxAge?: number
-    reportUri?: string
-  }
-  frameguard?: boolean | {
-    action?: 'deny' | 'sameorigin'
-    domain?: string
-  }
-  hidePoweredBy?: boolean
-  hsts?: boolean | {
-    maxAge?: number
-    includeSubDomains?: boolean
-    preload?: boolean
-  }
-  ieNoOpen?: boolean
-  noSniff?: boolean
-  originAgentCluster?: boolean
-  permittedCrossDomainPolicies?: boolean | {
-    permittedPolicies?: 'none' | 'master-only' | 'by-content-type' | 'all'
-  }
-  referrerPolicy?: boolean | {
-    policy?: string | string[]
-  }
-  xssFilter?: boolean | {
-    setOnOldIE?: boolean
-  }
-}
-export declare class Helmet {
-  private options: HelmetOptions;
-  constructor(options?: HelmetOptions);
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-}

package/dist/middleware/index.d.ts

@@ -1,55 +0,0 @@
-import Auth, { apiKeyAuth, basicAuth, bearerAuth, extractApiKey, extractBasicAuth, extractBearerToken, jwtAuth, oauth2Auth,  } from './auth';
-import Cors from './cors';
-import Csrf from './csrf';
-import JsonBody from './json_body';
-import RequestId from './request_id';
-import RequestSigning from './request_signing';
-import Session from './session';
-export type { NonceStore, RequestSigningOptions, SignatureAlgorithm, SignedPart } from './request_signing';
-export declare function auth(): Auth;
-// Factory functions for easier middleware creation
-export declare const cors: () => Cors;
-export declare const jsonBody: () => JsonBody;
-export declare const requestId: () => RequestId;
-export declare const session: () => Session;
-export declare const csrf: () => Csrf;
-export declare const middleware: Proxy;
-export { default as Auth } from './auth';
-export { default as ContentSecurityPolicy } from './content_security_policy';
-export { contentSecurityPolicy } from './content_security_policy';
-export { default as Cors } from './cors';
-export { default as Csrf } from './csrf';
-export { default as DDoSProtection } from './ddos_protection';
-export { ddosProtection } from './ddos_protection';
-export { default as FileSecurity } from './file_security';
-export { default as FileUpload } from './file_upload';
-export { documentUpload, fileUpload, imageUpload, multipleFileUpload, singleFileUpload } from './file_upload';
-export { default as Helmet } from './helmet';
-export { default as InputValidation } from './input_validation';
-export { inputValidation } from './input_validation';
-export { default as JsonBody } from './json_body';
-export { default as PerformanceAlerting, performanceAlerting } from './performance_alerting';
-export { default as PerformanceDashboard, performanceDashboard } from './performance_dashboard';
-export { default as PerformanceMonitor, performanceMonitor } from './performance_monitor';
-export { default as RateLimit } from './rate_limit';
-export { rateLimit } from './rate_limit';
-export { default as RequestId } from './request_id';
-export { InMemoryNonceStore, default as RequestSigning, requestSigning, signRequest, verifySignature } from './request_signing';
-export { SignatureError } from './request_signing';
-export { default as RequestTracer, requestTracer } from './request_tracer';
-export { default as Security } from './security';
-export { security } from './security';
-export { default as SecuritySuite } from './security_suite';
-export { securitySuite } from './security_suite';
-export { default as Session } from './session';
-export {
-  apiKeyAuth,
-  basicAuth,
-  bearerAuth,
-  extractApiKey,
-  extractBasicAuth,
-  extractBearerToken,
-  jwtAuth,
-  oauth2Auth,
-};
-export default middleware;

package/dist/middleware/input_validation.d.ts

@@ -1,46 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-// Factory function for easy use
-export declare function inputValidation(options?: InputValidationOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response>;
-export declare interface ValidationRule {
-  type: 'string' | 'number' | 'boolean' | 'email' | 'url' | 'uuid' | 'date' | 'regex' | 'custom'
-  required?: boolean
-  min?: number
-  max?: number
-  pattern?: RegExp
-  enum?: unknown[]
-  custom?: (value: unknown) => boolean | string
-  sanitize?: boolean
-  transform?: (value: unknown) => unknown
-}
-export declare interface ValidationSchema {
-
-}
-export declare interface InputValidationOptions {
-  enabled?: boolean
-  schemas?: {
-    query?: ValidationSchema
-    body?: ValidationSchema
-    headers?: ValidationSchema
-    params?: ValidationSchema
-  }
-  sanitizeByDefault?: boolean
-  strictMode?: boolean
-  allowUnknownFields?: boolean
-  maxDepth?: number
-  onValidationError?: (errors: ValidationError[]) => Response
-}
-export declare interface ValidationError {
-  field: string
-  message: string
-  value: any
-  rule: string
-}
-export declare class InputValidation {
-  private options: InputValidationOptions;
-  constructor(options?: InputValidationOptions);
-  private validateValue(value: any, rule: ValidationRule, fieldPath: string): ValidationError[];
-  private sanitizeValue(value: any, rule: ValidationRule): any;
-  private validateObject(obj: any, schema: ValidationSchema, basePath?: any, depth?: any): ValidationError[];
-  private parseRequestBody(req: EnhancedRequest): Promise<any>;
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-}

package/dist/middleware/json_body.d.ts

@@ -1,4 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-export declare class JsonBody {
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-}

package/dist/middleware/performance_alerting.d.ts

@@ -1,88 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-import type { PerformanceMetrics } from './performance_monitor';
-// Factory function for easy use
-export declare function performanceAlerting(options?: AlertingOptions): PerformanceAlerting;
-export declare interface AlertRule {
-  id: string
-  name: string
-  description?: string
-  enabled: boolean
-  metric: 'responseTime' | 'errorRate' | 'memoryUsage' | 'cpuUsage' | 'requestRate' | 'custom'
-  condition: 'gt' | 'lt' | 'eq' | 'gte' | 'lte'
-  threshold: number
-  duration?: number
-  severity: 'info' | 'warning' | 'critical'
-  cooldown?: number
-  customEvaluator?: (metrics: PerformanceMetrics[]) => boolean
-}
-export declare interface AlertNotification {
-  id: string
-  ruleId: string
-  ruleName: string
-  severity: 'info' | 'warning' | 'critical'
-  message: string
-  timestamp: number
-  resolved: boolean
-  resolvedAt?: number
-  metadata: Record<string, any>
-}
-export declare interface AlertChannel {
-  type: 'webhook' | 'slack' | 'email' | 'console' | 'custom'
-  enabled: boolean
-  config: {
-    url?: string
-    token?: string
-    channel?: string
-    email?: string
-    customHandler?: (notification: AlertNotification) => Promise<void>
-  }
-  filters?: {
-    severities?: Array<'info' | 'warning' | 'critical'>
-    rules?: string[]
-  }
-}
-export declare interface AlertingOptions {
-  enabled?: boolean
-  rules?: AlertRule[]
-  channels?: AlertChannel[]
-  defaultCooldown?: number
-  maxAlerts?: number
-  autoResolve?: boolean
-  autoResolveTimeout?: number
-}
-export declare class PerformanceAlerting {
-  private options: AlertingOptions;
-  private rules: Map<string, AlertRule>;
-  private channels: AlertChannel[];
-  private notifications: AlertNotification[];
-  private lastAlertTimes: Map<string, number>;
-  private metricsBuffer: PerformanceMetrics[];
-  private checkInterval?: Timer;
-  constructor(options?: AlertingOptions);
-  private addDefaultRules(): void;
-  private startAlertingEngine(): void;
-  private evaluateRules(): void;
-  private extractMetricValues(metrics: PerformanceMetrics[], metricType: string): number[];
-  private evaluateCondition(value: number, condition: string, threshold: number): boolean;
-  private triggerAlert(rule: AlertRule, value: any, metrics: PerformanceMetrics[]): Promise<void>;
-  private formatAlertMessage(rule: AlertRule, value: any, metrics: PerformanceMetrics[]): string;
-  private sendNotification(channel: AlertChannel, notification: AlertNotification): Promise<void>;
-  private sendConsoleNotification(notification: AlertNotification): void;
-  private sendWebhookNotification(channel: AlertChannel, notification: AlertNotification): Promise<void>;
-  private sendSlackNotification(channel: AlertChannel, notification: AlertNotification): Promise<void>;
-  private sendEmailNotification(channel: AlertChannel, notification: AlertNotification): Promise<void>;
-  private cleanupOldNotifications(): void;
-  private autoResolveAlerts(): void;
-  private generateId(): string;
-  addMetrics(metrics: PerformanceMetrics): void;
-  addRule(rule: AlertRule): void;
-  removeRule(ruleId: string): void;
-  updateRule(ruleId: string, updates: Partial<AlertRule>): void;
-  addChannel(channel: AlertChannel): void;
-  removeChannel(index: number): void;
-  getActiveAlerts(): AlertNotification[];
-  getAllNotifications(): AlertNotification[];
-  resolveAlert(alertId: string): void;
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-  destroy(): void;
-}

package/dist/middleware/performance_dashboard.d.ts

@@ -1,97 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-import type { TraceSpan } from './request_tracer';
-// Factory function for easy use
-export declare function performanceDashboard(options?: DashboardOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response | null>;
-export declare interface DashboardOptions {
-  enabled?: boolean
-  path?: string
-  title?: string
-  refreshInterval?: number
-  maxMetrics?: number
-  authentication?: {
-    enabled?: boolean
-    username?: string
-    password?: string
-    apiKey?: string
-  }
-  features?: {
-    realTimeMetrics?: boolean
-    historicalCharts?: boolean
-    alertsPanel?: boolean
-    tracingView?: boolean
-    systemMetrics?: boolean
-  }
-}
-export declare interface DashboardData {
-  metrics: {
-    current: {
-      totalRequests: number
-      averageResponseTime: number
-      errorRate: number
-      requestsPerSecond: number
-      memoryUsage: number
-      cpuUsage: number
-    }
-    historical: Array<{
-      timestamp: number
-      responseTime: number
-      memoryUsage: number
-      requestCount: number
-      errorCount: number
-    }>
-    distribution: {
-      statusCodes: Record<number, number>
-      paths: Record<string, number>
-      methods: Record<string, number>
-      responseTimes: Array<{ range: string, count: number }>
-    }
-  }
-  alerts: Array<{
-    id: string
-    type: 'warning' | 'critical'
-    message: string
-    timestamp: number
-    resolved: boolean
-  }>
-  traces: TraceSpan[]
-  system: {
-    uptime: number
-    nodeVersion: string
-    bunVersion: string
-    platform: string
-    arch: string
-    memory: NodeJS.MemoryUsage
-    cpu: NodeJS.CpuUsage
-  }
-}
-export declare class PerformanceDashboard {
-  private options: DashboardOptions;
-  private metricsHistory: Array<{
-    timestamp: number
-    responseTime: number
-    memoryUsage: number
-    requestCount: number
-    errorCount: number
-  }>;
-  private alerts: Array<{
-    id: string
-    type: 'warning' | 'critical'
-    message: string
-    timestamp: number
-    resolved: boolean
-  }>;
-  private startTime: number;
-  constructor(options?: DashboardOptions);
-  private isAuthenticated(req: EnhancedRequest): boolean;
-  private generateDashboardHTML(data: DashboardData): string;
-  private getDashboardData(performanceMonitor?: any, requestTracer?: any): Promise<DashboardData>;
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response | null>;
-  addAlert(type: 'warning' | 'critical', message: string): void;
-  resolveAlert(id: string): void;
-  updateMetricsHistory(data: {
-    responseTime: number
-    memoryUsage: number
-    requestCount: number
-    errorCount: number
-  }): void;
-}