@stacksjs/bun-router 0.0.2

package/dist/middleware/performance_monitor.d.ts

@@ -0,0 +1,236 @@
+import type { Middleware, NextFunction } from '../types';
+// Factory function for easy use
+export declare function performanceMonitor(options?: PerformanceMonitorOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response | null>;
+// Extend the EnhancedRequest interface to include profiling data
+export declare interface EnhancedRequest extends BaseEnhancedRequest {
+  profiling?: {
+    samples: any[]
+    systemSamples: any[]
+    requestId: string
+  }
+}
+export declare interface PerformanceMetrics {
+  requestId: string
+  method: string
+  path: string
+  statusCode: number
+  responseTime: number
+  memoryUsage: {
+    heapUsed: number
+    heapTotal: number
+    external: number
+    rss: number
+    arrayBuffers?: number
+  }
+  cpuUsage: {
+    user: number
+    system: number
+  }
+  timestamp: number
+  userAgent?: string
+  ip?: string
+  contentLength?: number
+  queryParams?: number | Record<string, string>
+  headers?: Record<string, string>
+  error?: string
+  traceId?: string
+  spanId?: string
+}
+export declare interface PerformanceThresholds {
+  responseTime: {
+    warning: number
+    critical: number
+  }
+  memoryUsage: {
+    warning: number
+    critical: number
+  }
+  errorRate: {
+    warning: number
+    critical: number
+  }
+}
+export declare interface PerformanceMonitorOptions {
+  enabled?: boolean
+  sampleRate?: number
+  maxRequestsPerSecond?: number
+  sampling?: {
+    enabled?: boolean
+    interval?: number
+    maxSamples?: number
+    rate?: number
+    maxRequestsPerSecond?: number
+  }
+  collectMetrics?: {
+    responseTime?: boolean
+    memoryUsage?: boolean
+    cpuUsage?: boolean
+    requestDetails?: boolean
+    headers?: boolean
+    queryParams?: boolean
+    userAgent?: boolean
+    ip?: boolean
+    contentLength?: boolean
+  }
+  includeHeaders?: boolean
+  includeQueryParams?: boolean
+  includeUserAgent?: boolean
+  includeIp?: boolean
+  includeContentLength?: boolean
+  thresholds?: {
+    responseTime?: {
+      warning?: number
+      critical?: number
+    }
+    memoryUsage?: {
+      warning?: number
+      critical?: number
+    }
+    errorRate?: {
+      warning?: number
+      critical?: number
+    }
+  }
+  customHandler?: (metrics: PerformanceMetrics) => Promise<void>
+  storage?: {
+    type: 'memory' | 'file' | 'database' | 'custom'
+    maxEntries?: number
+    retentionPeriod?: number
+    filePath?: string
+    customHandler?: (metrics: PerformanceMetrics) => Promise<void>
+  }
+  alerts?: {
+    enabled?: boolean
+    cooldown?: number
+    thresholds?: {
+      responseTime: number
+      memoryUsage: number
+      errorRate: number
+    }
+    handler?: (alert: {
+      type: string
+      message: string
+      value: number
+      threshold: number
+      path: string
+      method: string
+      statusCode: number
+      timestamp: number
+      severity: 'info' | 'warning' | 'critical'
+    }) => Promise<void>
+    customHandler?: (alert: {
+      type: string
+      message: string
+      value: number
+      threshold: number
+      path: string
+      method: string
+      statusCode: number
+      timestamp: number
+      severity: 'info' | 'warning' | 'critical'
+    }) => Promise<void>
+    webhookUrl?: string
+    emailConfig?: {
+      smtp: string
+      from: string
+      to: string[]
+    }
+    slackConfig?: {
+      webhookUrl: string
+      channel: string
+    }
+  }
+  profiling?: {
+    enabled?: boolean
+    sampleRate?: number
+    includeStackTrace?: boolean
+    maxStackDepth?: number
+    sampleInterval?: number
+    maxSamples?: number
+  }
+  tracing?: {
+    enabled?: boolean
+    sampleRate?: number
+    exporters?: ('console' | 'jaeger' | 'zipkin' | 'otlp')[]
+  }
+}
+declare type Timer = ReturnType<typeof setTimeout>
+export declare class PerformanceMonitor implements Middleware {
+  private options: PerformanceMonitorOptions;
+  private metrics: PerformanceMetrics[];
+  private lastAlertTime: Record<string, number>;
+  private requestsThisSecond: number;
+  private lastSecondTimestamp: number;
+  private requestContexts: Map<string, RequestContext>;
+  private samplingCounter: any;
+  private alertCooldowns: Map<string, number>;
+  private cleanupInterval?: Timer;
+  constructor(options?: PerformanceMonitorOptions);
+  private startCleanupInterval(): void;
+  private cleanupOldMetrics(): void;
+  private shouldSample(): boolean;
+  private generateTraceId(): string;
+  private generateSpanId(): string;
+  private getClientIP(req: EnhancedRequest): string;
+  private collectSystemMetrics(): Promise<{
+    memory: NodeJS.MemoryUsage
+    cpu: NodeJS.CpuUsage
+  }>;
+  private takeSample(profileData: any): void;
+  private calculateCpuPercent(start: NodeJS.CpuUsage, end: NodeJS.CpuUsage, duration: number): {
+    user: number
+    system: number
+  };
+  private storeMetrics(metrics: PerformanceMetrics): Promise<void>;
+  private checkThresholds(metrics: PerformanceMetrics): Promise<void>;
+  private sendAlert(alert: {
+    type: string
+    message: string
+    value: number
+    threshold: number
+    path: string
+    method: string
+    statusCode: number
+    timestamp: number
+    severity: 'info' | 'warning' | 'critical'
+  }): Promise<void>;
+  private sendAlerts(alerts: string[], metrics: PerformanceMetrics): Promise<void>;
+  private collectMetrics(params: {
+    req: EnhancedRequest
+    res: Response | null
+    startTime: number
+    startMemory: NodeJS.MemoryUsage
+    startCPU: NodeJS.CpuUsage
+    profilingSamples: any[]
+    error?: Error
+  }): Promise<PerformanceMetrics>;
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response | null>;
+  addMetrics(metrics: PerformanceMetrics): void;
+  checkThresholdsPublic(metrics: PerformanceMetrics): Promise<void>;
+  getMetrics(options?: {
+    startTime?: number
+    endTime?: number
+    path?: string
+    method?: string
+    statusCode?: number
+    limit?: number
+  }): PerformanceMetrics[];
+  getAggregatedMetrics(timeWindow?: number): {
+    totalRequests: number
+    averageResponseTime: number
+    medianResponseTime: number
+    p95ResponseTime: number
+    p99ResponseTime: number
+    errorRate: number
+    averageMemoryUsage: number
+    requestsPerSecond: number
+    statusCodeDistribution: Record<number, number>
+    pathDistribution: Record<string, number>
+  };
+  getProfiles(): Array<{
+    timestamp: number
+    memoryUsage: NodeJS.MemoryUsage
+    cpuUsage: NodeJS.CpuUsage
+  }>;
+  destroy(): void;
+}

package/dist/middleware/pipeline.d.ts

@@ -0,0 +1,90 @@
+import type { EnhancedRequest, MiddlewareHandler } from '../types';
+/**
+ * Skip condition factory functions
+ */
+export declare const SkipConditions: {
+  skipForMethods: (methods: string[]) => any;
+  skipForPaths: (paths: string[]) => any;
+  skipForHeaders: (headers: Record<string, string>) => any;
+  skipForRoles: (roles: string[]) => any;
+  skipForEnvironment: (environments: string[]) => any
+};
+/**
+ * Dependency factory functions
+ */
+export declare const Dependencies: {
+  database: (connectionString?: string) => any;
+  logger: (level: string?) => any;
+  cache: (maxSize: number?) => any;
+  httpClient: (baseURL?: string) => any
+};
+/**
+ * Middleware factory functions
+ */
+export declare const MiddlewareFactory: {
+  auth: (options: { secret?: string, skipPaths?: string[] } = {}) => any;
+  rateLimit: (options: { maxRequests: number, windowMs: number }) => any;
+  cors: (options: { origin?: string, methods?: string[] } = {}) => any;
+  logging: (_options: { level?: string } = {}) => any
+};
+/**
+ * Global middleware pipeline instance
+ */
+export declare const globalMiddlewarePipeline: MiddlewarePipeline;
+/**
+ * Middleware pipeline with composition caching, conditional execution,
+ * dependency injection, and short-circuiting capabilities
+ */
+export declare interface MiddlewareContext {
+  request: EnhancedRequest
+  route?: any
+  skipConditions?: MiddlewareSkipCondition[]
+  dependencies?: Map<string, any>
+  metadata?: Record<string, any>
+}
+export declare interface MiddlewareSkipCondition {
+  name: string
+  condition: (context: MiddlewareContext) => boolean | Promise<boolean>
+}
+export declare interface MiddlewareDependency {
+  name: string
+  factory: (context: MiddlewareContext) => any | Promise<any>
+  singleton?: boolean
+  dependencies?: string[]
+}
+export declare interface CompiledMiddleware {
+  handler: MiddlewareHandler
+  name: string
+  skipConditions: MiddlewareSkipCondition[]
+  dependencies: string[]
+  canShortCircuit: boolean
+  priority: number
+}
+export declare interface MiddlewarePipelineStats {
+  totalExecutions: number
+  cacheHits: number
+  cacheMisses: number
+  shortCircuits: number
+  skippedMiddleware: number
+  averageExecutionTime: number
+  dependencyResolutions: number
+}
+/**
+ * Middleware pipeline with advanced optimization features
+ */
+export declare class MiddlewarePipeline {
+  private compiledPipelines: any;
+  private dependencyRegistry: any;
+  private singletonInstances: any;
+  private stats: MiddlewarePipelineStats;
+  registerDependency(dependency: MiddlewareDependency): void;
+  compileMiddleware(routeKey: string, middleware: MiddlewareHandler[], skipConditions?: MiddlewareSkipCondition[]): void;
+  execute(routeKey: string, request: EnhancedRequest, finalHandler: () => Promise<Response>): Promise<Response>;
+  private shouldSkip(middleware: CompiledMiddleware, context: MiddlewareContext): Promise<boolean>;
+  private resolveDependencies(context: MiddlewareContext, pipeline: CompiledMiddleware[]): Promise<void>;
+  private extractDependencies(handler: MiddlewareHandler): string[];
+  private canShortCircuit(handler: MiddlewareHandler): boolean;
+  private updateAverageExecutionTime(executionTime: number): void;
+  getStats(): MiddlewarePipelineStats;
+  clear(): void;
+}

package/dist/middleware/rate_limit.d.ts

@@ -0,0 +1,33 @@
+import type { EnhancedRequest, Middleware, MiddlewareHandler, NextFunction } from '../types';
+// Export a factory function to create middleware handlers
+export declare function rateLimit(options?: RateLimitOptions): MiddlewareHandler;
+export declare interface RateLimitOptions {
+  windowMs?: number
+  maxRequests?: number
+  standardHeaders?: boolean
+  legacyHeaders?: boolean
+  skipFailedRequests?: boolean
+  keyGenerator?: (request: Request) => string | Promise<string>
+  handler?: (request: Request, limit: { remaining: number, limit: number, resetTime: number }) => Response | Promise<Response>
+  skip?: (request: Request) => boolean | Promise<boolean>
+  storage?: any
+  algorithm?: 'fixed-window' | 'sliding-window' | 'token-bucket'
+  draftMode?: boolean
+  redis?: {
+    url?: string
+    prefix?: string
+  }
+  tokenBucket?: {
+    tokensPerInterval?: number
+    interval?: number
+    burst?: number
+  }
+}
+export declare class RateLimit implements Middleware {
+  private limiter: any;
+  private options: RateLimitOptions;
+  constructor(options?: RateLimitOptions);
+  private initLimiter(): void;
+  private defaultHandler(req: Request, result: any): Response;
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+}

package/dist/middleware/request_id.d.ts

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

package/dist/middleware/request_signing.d.ts

@@ -0,0 +1,96 @@
+import type { EnhancedRequest, Middleware, NextFunction } from '../types';
+/**
+ * Factory function to create request signing middleware
+ */
+export declare function requestSigning(options: RequestSigningOptions): RequestSigning;
+/**
+ * Helper to sign a request (for clients)
+ */
+export declare function signRequest(request: Request, secret: string, options?: {
+    algorithm?: SignatureAlgorithm
+    signedParts?: SignedPart[]
+    signedHeaders?: string[]
+    signatureHeader?: string
+    timestampHeader?: string
+    nonceHeader?: string
+    keyId?: string
+    keyIdHeader?: string
+    encoding?: 'hex' | 'base64'
+  }): Promise<Request>;
+/**
+ * Verify a signature (utility function)
+ */
+export declare function verifySignature(stringToSign: string, signature: string, secret: string, algorithm?: SignatureAlgorithm, encoding?: 'hex' | 'base64'): Promise<boolean>;
+export declare interface RequestSigningOptions {
+  secret: string | ((keyId: string) => string | Promise<string | null> | null)
+  algorithm?: SignatureAlgorithm
+  signatureHeader?: string
+  timestampHeader?: string
+  keyIdHeader?: string
+  nonceHeader?: string
+  maxAge?: number
+  requireTimestamp?: boolean
+  requireNonce?: boolean
+  nonceStore?: NonceStore
+  signedParts?: SignedPart[]
+  stringToSign?: (req: EnhancedRequest, timestamp: string, nonce?: string) => Promise<string> | string
+  onError?: (error: SignatureError, req: EnhancedRequest) => Response | Promise<Response>
+  exclude?: string[] | ((req: EnhancedRequest) => boolean)
+  signedHeaders?: string[]
+  encoding?: 'hex' | 'base64'
+}
+export declare interface NonceStore {
+  has: (nonce: string) => Promise<boolean> | boolean
+  set: (nonce: string, expiry?: number) => Promise<void> | void
+}
+export type SignatureAlgorithm = 'sha256' | 'sha384' | 'sha512'
+export type SignedPart = 'method' | 'path' | 'query' | 'timestamp' | 'body' | 'nonce' | 'headers'
+export type SignatureErrorCode = | 'MISSING_SIGNATURE'
+  | 'MISSING_TIMESTAMP'
+  | 'MISSING_NONCE'
+  | 'MISSING_KEY_ID'
+  | 'INVALID_KEY'
+  | 'INVALID_SIGNATURE'
+  | 'EXPIRED_TIMESTAMP'
+  | 'FUTURE_TIMESTAMP'
+  | 'NONCE_REUSED'
+  | 'SIGNATURE_MISMATCH'
+export declare class SignatureError extends Error {
+  readonly code: SignatureErrorCode;
+  readonly statusCode: number;
+  constructor(code: SignatureErrorCode, message: string);
+}
+/**
+ * In-memory nonce store with automatic expiry
+ */
+export declare class InMemoryNonceStore implements NonceStore {
+  private nonces: any;
+  private cleanupInterval: ReturnType<typeof setInterval> | null;
+  constructor(cleanupIntervalMs?: number);
+  has(nonce: string): boolean;
+  set(nonce: string, expirySeconds?: number): void;
+  private cleanup(): void;
+  destroy(): void;
+}
+/**
+ * Request Signing Middleware
+ */
+export declare class RequestSigning implements Middleware {
+  private options: Required<Omit<RequestSigningOptions, 'onError' | 'exclude' | 'nonceStore' | 'stringToSign'>> & {
+    onError?: RequestSigningOptions['onError']
+    exclude?: RequestSigningOptions['exclude']
+    nonceStore?: NonceStore
+    stringToSign?: RequestSigningOptions['stringToSign']
+  };
+  constructor(options: RequestSigningOptions);
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response | null>;
+  private shouldSkip(req: EnhancedRequest): boolean;
+  private verifySignature(req: EnhancedRequest): Promise<void>;
+  private getSecret(req: EnhancedRequest): Promise<string | null>;
+  private validateTimestamp(timestamp: string): void;
+  private validateNonce(nonce: string): Promise<void>;
+  private buildStringToSign(req: EnhancedRequest, timestamp: string, nonce?: string): Promise<string>;
+  private calculateSignature(data: string, secret: string): Promise<string>;
+  private timingSafeEqual(a: string, b: string): boolean;
+  private defaultErrorResponse(error: SignatureError): Response;
+}

package/dist/middleware/request_tracer.d.ts

@@ -0,0 +1,76 @@
+import type { EnhancedRequest, NextFunction } from '../types';
+// Factory function for easy use
+export declare function requestTracer(options?: TracingOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response>;
+export declare interface TraceSpan {
+  traceId: string
+  spanId: string
+  parentSpanId?: string
+  operationName: string
+  startTime: number
+  endTime?: number
+  duration?: number
+  tags: Record<string, any>
+  logs: Array<{
+    timestamp: number
+    level: 'debug' | 'info' | 'warn' | 'error'
+    message: string
+    fields?: Record<string, any>
+  }>
+  status: 'ok' | 'error' | 'timeout'
+  error?: string
+  stackTrace?: string[]
+}
+export declare interface TracingOptions {
+  enabled?: boolean
+  sampleRate?: number
+  maxSpans?: number
+  includeHeaders?: boolean
+  includeQueryParams?: boolean
+  includeRequestBody?: boolean
+  includeResponseBody?: boolean
+  maxBodySize?: number
+  exporters?: Array<{
+    type: 'console' | 'jaeger' | 'zipkin' | 'otlp' | 'custom'
+    endpoint?: string
+    headers?: Record<string, string>
+    customExporter?: (spans: TraceSpan[]) => Promise<void>
+  }>
+  propagation?: {
+    enabled?: boolean
+    headers?: string[]
+  }
+}
+export declare class RequestTracer {
+  private options: TracingOptions;
+  private spans: Map<string, TraceSpan>;
+  private activeSpans: Map<string, string>;
+  private exportQueue: TraceSpan[];
+  private exportInterval?: Timer;
+  constructor(options?: TracingOptions);
+  private startExportInterval(): void;
+  private shouldSample(): boolean;
+  private generateId(): string;
+  private extractPropagationHeaders(req: EnhancedRequest): {
+    traceId?: string
+    parentSpanId?: string
+  };
+  private captureRequestBody(req: EnhancedRequest): Promise<any>;
+  private captureResponseBody(response: Response): Promise<any>;
+  private createSpan(traceId: string, spanId: string, operationName: string, parentSpanId?: string): TraceSpan;
+  private addSpanTag(spanId: string, key: string, value: any): void;
+  private addSpanLog(spanId: string, level: 'debug' | 'info' | 'warn' | 'error', message: string, fields?: Record<string, any>): void;
+  private finishSpan(spanId: string, status?: 'ok' | 'error' | 'timeout', error?: string): void;
+  private exportSpans(): Promise<void>;
+  private exportToConsole(spans: TraceSpan[]): void;
+  private exportToJaeger(spans: TraceSpan[], exporter: any): Promise<void>;
+  private exportToZipkin(spans: TraceSpan[], exporter: any): Promise<void>;
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+  getActiveSpans(): TraceSpan[];
+  getSpanById(spanId: string): TraceSpan | undefined;
+  createChildSpan(parentSpanId: string, operationName: string): string | null;
+  addTag(spanId: string, key: string, value: any): void;
+  addLog(spanId: string, level: 'debug' | 'info' | 'warn' | 'error', message: string, fields?: Record<string, any>): void;
+  finish(spanId: string, status?: 'ok' | 'error' | 'timeout', error?: string): void;
+  flush(): Promise<void>;
+  destroy(): void;
+}

package/dist/middleware/response_cache.d.ts

@@ -0,0 +1,90 @@
+import type { EnhancedRequest, Middleware, NextFunction } from '../types';
+// Factory functions
+export declare function responseCache(options?: ResponseCacheOptions): ResponseCache;
+export declare function memoryCache(options?: Omit<ResponseCacheOptions, 'storage'>): ResponseCache;
+export declare function fileCache(directory?: string, options?: Omit<ResponseCacheOptions, 'storage'>): ResponseCache;
+export declare function hybridCache(options?: ResponseCacheOptions): ResponseCache;
+export declare interface CacheEntry {
+  key: string
+  response: {
+    status: number
+    statusText: string
+    headers: Record<string, string>
+    body: number[] // Store as number array for JSON serialization
+    contentType: string
+  }
+  createdAt: number
+  expiresAt: number
+  etag?: string
+  lastModified?: string
+  size: number
+}
+export declare interface ResponseCacheOptions {
+  enabled?: boolean
+  storage?: {
+    type: 'memory' | 'file' | 'hybrid'
+    directory?: string
+    maxSize?: number
+    maxEntries?: number
+  }
+  ttl?: {
+    default: number
+    routes?: Record<string, number>
+    methods?: Record<string, number>
+  }
+  keyGenerator?: (req: EnhancedRequest) => string
+  shouldCache?: (req: EnhancedRequest, res: Response) => boolean
+  varyHeaders?: string[]
+  compression?: {
+    enabled: boolean
+    threshold: number
+    algorithms: ('gzip' | 'deflate' | 'br')[]
+  }
+  invalidation?: {
+    patterns?: string[]
+    methods?: string[]
+    headers?: string[]
+  }
+  etag?: {
+    enabled: boolean
+    weak: boolean
+  }
+  staleWhileRevalidate?: {
+    enabled: boolean
+    maxAge: number
+  }
+}
+export declare class ResponseCache implements Middleware {
+  private options: Required<ResponseCacheOptions>;
+  private memoryCache: any;
+  private cacheStats: any;
+  private cleanupInterval?: Timer;
+  constructor(options?: ResponseCacheOptions);
+  private initializeStorage(): Promise<void>;
+  private startCleanupInterval(): void;
+  cleanup(): Promise<void>;
+  private cleanupFileCache(): Promise<void>;
+  private defaultKeyGenerator(req: EnhancedRequest): string;
+  private defaultShouldCache(req: EnhancedRequest, res: Response): boolean;
+  private getTTL(req: EnhancedRequest): number;
+  private generateETag(content: string | Uint8Array): string;
+  private getFromMemoryCache(key: string): Promise<CacheEntry | null>;
+  private getFromFileCache(key: string): Promise<CacheEntry | null>;
+  private setMemoryCache(key: string, entry: CacheEntry): Promise<void>;
+  private setFileCache(key: string, entry: CacheEntry): Promise<void>;
+  private evictLRU(): void;
+  private updateCacheStats(): void;
+  private generateCacheKey(req: EnhancedRequest): string;
+  private getCachedResponse(key: string): Promise<CacheEntry | null>;
+  private setCachedResponse(key: string, entry: CacheEntry): Promise<void>;
+  private handleConditionalRequest(req: EnhancedRequest, entry: CacheEntry): Response | null;
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+  private deleteCachedResponse(key: string): Promise<void>;
+  private createCacheEntry(req: EnhancedRequest, res: Response): Promise<{ entry: CacheEntry, response: Response }>;
+  private createResponseFromEntry(entry: CacheEntry): Response;
+  private backgroundRevalidate(cacheKey: string, req: EnhancedRequest, next: NextFunction): Promise<void>;
+  invalidateCache(req?: EnhancedRequest): Promise<void>;
+  clearCache(): Promise<void>;
+  getStats(): { hits: number, misses: number, sets: number, deletes: number, size: number, memoryUsage: number, hitRate: number };
+  destroy(): void;
+}

package/dist/middleware/security.d.ts

@@ -0,0 +1,70 @@
+import type { EnhancedRequest, NextFunction } from '../types';
+// Factory function for easy use
+export declare function security(options?: SecurityOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response>;
+export declare interface SecurityOptions {
+  inputValidation?: {
+    enabled?: boolean
+    maxBodySize?: number
+    maxUrlLength?: number
+    maxHeaderSize?: number
+    allowedContentTypes?: string[]
+    sanitizeInput?: boolean
+    validateEncoding?: boolean
+  }
+  requestFiltering?: {
+    enabled?: boolean
+    blockSuspiciousPatterns?: boolean
+    maxRequestsPerMinute?: number
+    blockUserAgents?: string[]
+    allowedMethods?: string[]
+    requireUserAgent?: boolean
+  }
+  ipFiltering?: {
+    enabled?: boolean
+    whitelist?: string[]
+    blacklist?: string[]
+    blockPrivateIPs?: boolean
+    blockCloudProviders?: boolean
+    geoBlocking?: {
+      enabled?: boolean
+      allowedCountries?: string[]
+      blockedCountries?: string[]
+    }
+  }
+  attackPrevention?: {
+    enabled?: boolean
+    sqlInjection?: boolean
+    xss?: boolean
+    pathTraversal?: boolean
+    commandInjection?: boolean
+    ldapInjection?: boolean
+    xxe?: boolean
+    customPatterns?: Array<{
+      name: string
+      pattern: RegExp
+      action: 'block' | 'log' | 'sanitize'
+    }>
+  }
+  responseSecurity?: {
+    enabled?: boolean
+    removeServerHeaders?: boolean
+    addSecurityHeaders?: boolean
+    sanitizeErrors?: boolean
+    preventInfoDisclosure?: boolean
+  }
+}
+export declare class Security {
+  private options: SecurityOptions;
+  private suspiciousPatterns: RegExp[];
+  private sqlInjectionPatterns: RegExp[];
+  private xssPatterns: RegExp[];
+  private pathTraversalPatterns: RegExp[];
+  private commandInjectionPatterns: RegExp[];
+  constructor(options?: SecurityOptions);
+  private initializePatterns(): void;
+  private getClientIP(req: EnhancedRequest): string;
+  private isPrivateIP(ip: string): boolean;
+  private validateInput(input: string): { isValid: boolean, threats: string[] };
+  private sanitizeInput(input: string): string;
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+}