@stacksjs/bun-router 0.0.2 → 0.0.3

package/dist/middleware/performance_monitor.d.ts

@@ -1,236 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

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

package/dist/middleware/request_signing.d.ts

@@ -1,96 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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>;
-}