@stacksjs/bun-router 0.0.2 → 0.0.4

package/dist/router/route-building.d.ts

@@ -1,5 +0,0 @@
-import type { Router } from './router';
-/**
- * Route building extension for Router class
- */
-export declare function registerRouteBuilding(RouterClass: typeof Router): void;

package/dist/router/route-compiler.d.ts

@@ -1,67 +0,0 @@
-import { RouteTrie } from './route-trie';
-import type { CompiledRoute } from './route-trie';
-import type { HTTPMethod, MatchResult, PatternMatchResult, Route } from '../types';
-/**
- * Route compilation options
- */
-export declare interface RouteCompilerOptions {
-  enableCaching: boolean
-  enableMethodGrouping: boolean
-  enablePriorityOptimization: boolean
-  cacheSize: number
-  precompilePatterns: boolean
-}
-/**
- * Route matching statistics for performance monitoring
- */
-export declare interface RouteMatchStats {
-  totalMatches: number
-  cacheHits: number
-  cacheMisses: number
-  averageMatchTime: number
-  trieDepth: number
-  methodDistribution: Record<string, number>
-}
-/**
- * High-performance route compiler with pre-compilation and optimization
- */
-export declare class RouteCompiler {
-  private trie: RouteTrie;
-  private matchCache: Map<string, MatchResult | null>;
-  private cacheKeys: string[];
-  private stats: RouteMatchStats;
-  private options: RouteCompilerOptions;
-  constructor(options?: Partial<RouteCompilerOptions>);
-  addRoute(route: Route): boolean;
-  private checkForDuplicateRoute(route: Route): boolean;
-  private patternCache: Map<string, { exec: (url: URL) => PatternMatchResult | null }>;
-  private extractParamNames(path: string): string[];
-  private precompileRoutePattern(route: Route): void;
-  private convertToURLPattern(path: string, constraints?: Record<string, string>): { exec: (pathname: string) => { groups?: Record<string, string> } | null };
-  match(path: string, method: HTTPMethod): MatchResult | null;
-  private addToCache(key: string, value: MatchResult | null): void;
-  private updateCacheLRU(key: string): void;
-  private updateMatchTime(startTime: number): void;
-  getCompiledRoutes(): CompiledRoute[];
-  getRoutesByMethod(): Map<HTTPMethod, CompiledRoute[]>;
-  warmCache(commonPaths: Array<{ path: string, method: HTTPMethod }>, options?: { force?: boolean, precompile?: boolean }): { warmedPaths: number, cacheSize: number, hitRate: number };
-  clear(): void;
-  getStats(): RouteMatchStats;
-  getCacheStats(): {
-    size: number
-    maxSize: number
-    hitRate: number
-    enabled: boolean
-  };
-  optimizeRouteOrder(_usageStats: Record<string, number>): void;
-  getRouteConflicts(): Array<{
-    routes: CompiledRoute[]
-    conflictType: 'overlap' | 'duplicate' | 'ambiguous'
-    severity: 'low' | 'medium' | 'high'
-  }>;
-  private routesConflict(route1: CompiledRoute, route2: CompiledRoute): boolean;
-  private patternsOverlap(segments1: any[], segments2: any[]): boolean;
-  private getConflictSeverity(route1: CompiledRoute, route2: CompiledRoute): 'low' | 'medium' | 'high';
-  private getConflictType(route1: CompiledRoute, route2: CompiledRoute): 'overlap' | 'duplicate' | 'ambiguous';
-  private hasAmbiguousParameters(route1: CompiledRoute, route2: CompiledRoute): boolean;
-}

package/dist/router/route-matching.d.ts

@@ -1,5 +0,0 @@
-import type { Router } from './router';
-/**
- * Route matching extension for Router class
- */
-export declare function registerRouteMatching(RouterClass: typeof Router): void;

package/dist/router/route-trie.d.ts

@@ -1,69 +0,0 @@
-import type { HTTPMethod, Route } from '../types';
-export declare interface RouteSegment {
-  type: RouteSegmentType
-  value: string
-  paramName?: string
-  pattern?: RegExp
-  optional?: boolean
-}
-export declare interface CompiledRoute {
-  route: Route
-  segments: RouteSegment[]
-  paramNames: string[]
-  priority: number
-  staticScore: number
-  dynamicScore: number
-}
-/**
- * Route matching result with extracted parameters
- */
-export declare interface RouteMatch {
-  route: Route
-  params: Record<string, string>
-  score: number
-}
-/**
- * Route segment types for the trie
- */
-export type RouteSegmentType = 'static' | 'parameter' | 'wildcard' | 'optional'
-/**
- * Trie node for efficient route matching
- */
-export declare class TrieNode {
-  children: Map<string, TrieNode>;
-  paramChild: TrieNode | null;
-  wildcardChild: TrieNode | null;
-  routes: Map<HTTPMethod, CompiledRoute>;
-  paramName: string | null;
-  pattern: RegExp | null;
-  isEndpoint: boolean;
-  addRoute(method: HTTPMethod, compiledRoute: CompiledRoute): void;
-  getRoute(method: HTTPMethod): CompiledRoute | undefined;
-  getAllRoutes(): CompiledRoute[];
-}
-/**
- * High-performance route trie for O(log n) route matching
- */
-export declare class RouteTrie {
-  private root: TrieNode;
-  private compiledRoutes: Map<string, CompiledRoute>;
-  private methodTries: Map<HTTPMethod, TrieNode>;
-  constructor();
-  compileRoute(route: Route): CompiledRoute;
-  private parsePathSegments(path: string): RouteSegment[];
-  private calculateRoutePriority(segments: RouteSegment[]): number;
-  addRoute(route: Route): void;
-  private insertRoute(node: TrieNode, compiled: CompiledRoute, segmentIndex: number): void;
-  match(path: string, method: HTTPMethod): RouteMatch | null;
-  private matchSegments(node: TrieNode, segments: string[], segmentIndex: number, params: Record<string, string>, method: HTTPMethod): RouteMatch | null;
-  getAllRoutes(): CompiledRoute[];
-  removeRoute(route: Route): void;
-  clear(): void;
-  getStats(): {
-    totalRoutes: number
-    totalNodes: number
-    averageDepth: number
-    methodDistribution: Record<string, number>
-  };
-  private countNodes(node: TrieNode): number;
-}

package/dist/router/router.d.ts

@@ -1,133 +0,0 @@
-import type { Server } from 'bun';
-import type { ActionHandler, CookieOptions, EnhancedRequest, MiddlewareHandler, Route, RouteGroup, RouteHandler, RouterConfig, WebSocketConfig, WebSocketData,  } from '../types';
-import type { MiddlewareDependency, MiddlewarePipeline, MiddlewarePipelineStats, MiddlewareSkipCondition } from '../middleware/pipeline';
-export type {
-  ActionHandler,
-  MiddlewareHandler,
-  Route,
-  RouteGroup,
-  RouteHandler,
-  RouterConfig,
-  WebSocketConfig,
-};
-/**
- * Route compiler interface for pattern matching
- */
-export declare interface RouteCompiler {
-  compile: (path: string) => RegExp
-  match: (path: string, pattern: RegExp) => Record<string, string> | null
-}
-/**
- * Middleware cache info interface
- */
-export declare interface MiddlewareCacheInfo {
-  size: number
-  routes: string[]
-  hitRate: number
-}
-// Middleware condition type
-export type MiddlewareCondition = (req: EnhancedRequest) => boolean
-/**
- * Unified Router class with advanced middleware patterns
- */
-export declare class Router {
-  routes: Route[];
-  currentGroup: RouteGroup | null;
-  globalMiddleware: MiddlewareHandler[];
-  namedRoutes: Map<string, Route>;
-  fallbackHandler: ActionHandler | null;
-  patterns: Map<string, string>;
-  currentDomain: string | null;
-  domains: Record<string, Route[]>;
-  serverInstance: Server<WebSocketData> | null;
-  wsConfig: WebSocketConfig | null;
-  errorHandler: ((error: Error) => Response | Promise<Response>) | null;
-  templateCache: Map<string, string>;
-  routeCache: Map<string, { route: Route, params: Record<string, string> }>;
-  staticRoutes: Map<string, Map<string, Route>>;
-  precompiledPatterns: Map<string, RegExp>;
-  domainPatternCache: Map<string, RegExp>;
-  routeCompiler: RouteCompiler | null;
-  private middlewareGroups: Map<string, MiddlewareHandler[]>;
-  private namedMiddleware: Map<string, (params?: string) => MiddlewareHandler>;
-  private conditionalMiddleware: Array<{ condition: MiddlewareCondition, middleware: MiddlewareHandler[] }>;
-  _middlewarePipeline?: MiddlewarePipeline;
-  config: RouterConfig;
-  constructor(config?: Partial<RouterConfig>);
-  private initializeDefaultMiddleware(): void;
-  middlewareGroup(name: string, middlewareNames: string[]): this;
-  middlewareGroupRoutes(name: string): RouteGroupBuilder;
-  when(condition: MiddlewareCondition): ConditionalBuilder;
-  middleware(middlewareName: string): MiddlewareBuilder;
-  getServer(): Server<WebSocketData> | null;
-  extend(methods: Record<string, (...args: unknown[]) => unknown>): Router;
-  invalidateCache(): void;
-  registerRoute(method: string, path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Promise<Router>;
-  resolveMiddleware(middleware: string | MiddlewareHandler): Promise<MiddlewareHandler | null>;
-  get(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Promise<Router>;
-  post(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Promise<Router>;
-  put(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Promise<Router>;
-  patch(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Promise<Router>;
-  delete(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Promise<Router>;
-  options(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Promise<Router>;
-  match(methods: string[], path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Promise<Router>;
-  any(path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: (string | MiddlewareHandler)[]): Promise<Router>;
-  fallback(handler: ActionHandler): Router;
-  route(name: string, params?: Record<string, string>): string;
-  onError(handler: (error: Error) => Response | Promise<Response>): Router;
-  redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): Response;
-  permanentRedirect(url: string): Response;
-  redirectRoute(from: string, to: string, status?: 301 | 302 | 303 | 307 | 308): Promise<Router>;
-  serve(options?: { port?: number, hostname?: string }): Promise<Server<WebSocketData>>;
-  handleRequest(req: Request): Promise<Response>;
-  getAllowedMethods(path: string, domain?: string): string[];
-  matchRoute(path: string, method: string, domain?: string): { route: Route, params: Record<string, string> } | undefined;
-  enhanceRequest(req: Request, params?: Record<string, string>): EnhancedRequest;
-  applyModifiedCookies(response: Response, req: EnhancedRequest): Response;
-  serializeCookie(name: string, value: string, options?: CookieOptions): string;
-  buildMiddlewareChain(middlewares: MiddlewareHandler[]): (req: EnhancedRequest) => Promise<Response | null>;
-  runMiddleware(req: EnhancedRequest, middlewareStack: MiddlewareHandler[]): Promise<Response | null>;
-  resolveHandler(handler: ActionHandler, req: EnhancedRequest): Promise<Response>;
-  use(middleware: (string | MiddlewareHandler)[]): Promise<Router>;
-  group(options: { prefix?: string, middleware?: (string | MiddlewareHandler)[] }, callback: () => void | Promise<void>): Router;
-  addRoute(route: Route): this;
-  registerMiddlewareDependency(dependency: MiddlewareDependency): this;
-  registerMiddlewareSkipConditions(_middlewareName: string, _conditions: MiddlewareSkipCondition[]): this;
-  getMiddlewareStats(): MiddlewarePipelineStats | Record<string, never>;
-  getMiddlewareCacheInfo(): MiddlewareCacheInfo;
-  clearMiddlewareCache(): this;
-  executeMiddleware(middleware: MiddlewareHandler[], request: EnhancedRequest, handler: () => Promise<Response>): Promise<Response>;
-}
-/**
- * Builder for conditional middleware
- */
-export declare class ConditionalBuilder {
-  private router: Router;
-  private condition: MiddlewareCondition;
-  constructor(router: Router, condition: MiddlewareCondition);
-  middleware(middlewareName: string): this;
-}
-/**
- * Builder for middleware with parameters
- */
-export declare class MiddlewareBuilder {
-  private router: Router;
-  private middleware: MiddlewareHandler[];
-  constructor(router: Router, middleware: MiddlewareHandler[]);
-  get(_path: string, _handler: RouteHandler): this;
-  post(_path: string, _handler: RouteHandler): this;
-  put(_path: string, _handler: RouteHandler): this;
-  delete(_path: string, _handler: RouteHandler): this;
-}
-/**
- * Builder for route groups with middleware
- */
-export declare class RouteGroupBuilder {
-  private router: Router;
-  private middleware: MiddlewareHandler[];
-  constructor(router: Router, middleware: MiddlewareHandler[]);
-  get(_path: string, _handler: RouteHandler): this;
-  post(_path: string, _handler: RouteHandler): this;
-  put(_path: string, _handler: RouteHandler): this;
-  delete(_path: string, _handler: RouteHandler): this;
-}

package/dist/router/server.d.ts

@@ -1,5 +0,0 @@
-import type { Router } from './router';
-/**
- * Server handling extension for Router class
- */
-export declare function registerServerHandling(RouterClass: typeof Router): void;

package/dist/router/validation-integration.d.ts

@@ -1,116 +0,0 @@
-import type { EnhancedRequest, MiddlewareHandler, RouteHandler } from '../types';
-import type { ValidationRules, ValidatorConfig } from '../validation/validator';
-/**
- * Router middleware factory for request/response enhancements
- */
-export declare function createEnhancementMiddleware(): void;
-/**
- * Factory function to create validation middleware builder
- */
-export declare function validate(): ValidationMiddlewareBuilder;
-/**
- * Fluent router factory
- */
-export declare function createFluentRouter(): FluentRouter;
-/**
- * Route helper functions
- */
-export declare const RouteHelpers: {
-  validated: (method: string, path: string, handler: RouteHandler, rules: ValidationRules, config?: ValidatorConfig) => RouteBuilder
-  apiRoute: (method: string, path: string, handler: RouteHandler, rules?: ValidationRules) => RouteBuilder
-  resourceRoute: (basePath: string, handlers: ResourceHandlers, validation?: ResourceValidation) => RouteBuilder[]
-};
-/**
- * Middleware composition helpers
- */
-export declare const MiddlewareHelpers: {
-  /**
-   * Compose multiple middleware into one
-   */
-  compose: (...middleware: MiddlewareHandler[]) => any;
-  /**
-   * Create conditional middleware
-   */
-  when: ( condition: (req: EnhancedRequest) => boolean, middleware: MiddlewareHandler, ) => any;
-  /**
-   * Create middleware that runs unless condition is met
-   */
-  unless: ( condition: (req: EnhancedRequest) => boolean, middleware: MiddlewareHandler, ) => any;
-  /**
-   * Create middleware group
-   */
-  group: (middleware: MiddlewareHandler[]) => any
-};
-/**
- * Request/Response enhancement presets
- */
-export declare const EnhancementPresets: {
-  api: () => EnhancementMiddleware[]
-  web: () => EnhancementMiddleware[]
-  validation: (rules: ValidationRules, config?: ValidatorConfig) => EnhancementMiddleware[]
-};
-/** Resource handlers configuration */
-export declare interface ResourceHandlers {
-  index?: RouteHandler
-  show?: RouteHandler
-  store?: RouteHandler
-  update?: RouteHandler
-  destroy?: RouteHandler
-}
-/** Resource validation configuration */
-export declare interface ResourceValidation {
-  store?: ValidationRules
-  update?: ValidationRules
-}
-/** Enhancement middleware type */
-export type EnhancementMiddleware = (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>
-/**
- * Route builder with validation support
- */
-export declare class RouteBuilder {
-  private validationRules?: ValidationRules;
-  private validatorConfig?: ValidatorConfig;
-  private method: string;
-  private path: string;
-  private handler: RouteHandler;
-  constructor(method: string, path: string, handler: RouteHandler);
-  validate(rules: ValidationRules, config?: ValidatorConfig): this;
-  build(): { method: string, path: string, handler: RouteHandler, middleware?: MiddlewareHandler[] };
-}
-/**
- * Fluent router for enhanced routing functionality
- */
-export declare class FluentRouter {
-  private routes: Array<{
-    method: string
-    path: string
-    handler: RouteHandler
-    middleware?: MiddlewareHandler[]
-  }>;
-  get(path: string, handler: RouteHandler): RouteBuilder;
-  post(path: string, handler: RouteHandler): RouteBuilder;
-  put(path: string, handler: RouteHandler): RouteBuilder;
-  patch(path: string, handler: RouteHandler): RouteBuilder;
-  delete(path: string, handler: RouteHandler): RouteBuilder;
-  register(routeBuilder: RouteBuilder): void;
-  getRoutes(): Array<{
-    method: string
-    path: string
-    handler: RouteHandler
-    middleware?: MiddlewareHandler[]
-  }>;
-}
-/**
- * Validation middleware factory with fluent API
- */
-export declare class ValidationMiddlewareBuilder {
-  private rules: ValidationRules;
-  private config: ValidatorConfig;
-  field(name: string, rules: string): this;
-  fields(rules: ValidationRules): this;
-  configure(config: ValidatorConfig): this;
-  stopOnFirstFailure(): this;
-  messages(messages: Record<string, string>): this;
-  attributes(attributes: Record<string, string>): this;
-  build(): MiddlewareHandler;
-}

package/dist/router/view-rendering.d.ts

@@ -1,5 +0,0 @@
-import type { Router } from './router';
-/**
- * View rendering extension for Router class
- */
-export declare function registerViewRendering(RouterClass: typeof Router): void;

package/dist/router/websocket.d.ts

@@ -1,5 +0,0 @@
-import type { Router } from './router';
-/**
- * WebSocket extension for Router class
- */
-export declare function registerWebSocketHandling(RouterClass: typeof Router): void;

package/dist/routing/route-caching.d.ts

@@ -1,105 +0,0 @@
-import { LRUCache } from '../cache/lru-cache';
-import type { EnhancedRequest } from '../types';
-/**
- * Create route caching middleware
- */
-export declare function createRouteCacheMiddleware(config: RouteCacheConfig): void;
-/**
- * Global route cache manager instance
- */
-export declare const routeCacheManager: RouteCacheManager;
-/**
- * Factory functions for common cache configurations
- */
-export declare const RouteCacheFactory: {
-  /**
-   * Short-term cache (5 minutes)
-   */
-  short: (tags: string[] = []) => any;
-  /**
-   * Medium-term cache (1 hour)
-   */
-  medium: (tags: string[] = []) => any;
-  /**
-   * Long-term cache (24 hours)
-   */
-  long: (tags: string[] = []) => any;
-  /**
-   * API response cache with common settings
-   */
-  api: (tags: string[] = []) => any;
-  /**
-   * Static content cache
-   */
-  static: (tags: string[] = []) => any;
-  /**
-   * User-specific cache
-   */
-  user: (tags: string[] = []) => any
-};
-/**
- * Cache invalidation utilities
- */
-export declare const CacheInvalidation: {
-  /**
-   * Invalidate by tags
-   */
-  byTags: (tags: string[]) => any;
-  /**
-   * Invalidate all user-related cache
-   */
-  forUser: (userId: string) => any;
-  /**
-   * Invalidate model-related cache
-   */
-  forModel: (modelName: string, id?: string) => any;
-  /**
-   * Clear all cache
-   */
-  all: () => any
-};
-/**
- * Route caching configuration
- */
-export declare interface RouteCacheConfig {
-  ttl?: number
-  maxSize?: number
-  tags?: string[]
-  varyBy?: string[]
-  excludeQuery?: string[]
-  condition?: (req: EnhancedRequest) => boolean
-}
-/**
- * Cached response metadata
- */
-export declare interface CachedResponse {
-  response: Response
-  headers: Record<string, string>
-  status: number
-  body: string | Uint8Array
-  timestamp: number
-  ttl?: number
-  tags: string[]
-  etag?: string
-}
-/**
- * Cache key generator for route responses
- */
-export declare class RouteCacheKeyGenerator {
-  static generateKey(req: EnhancedRequest, config: RouteCacheConfig): string;
-}
-/**
- * Route cache manager with tag-based invalidation
- */
-export declare class RouteCacheManager {
-  private cache: LRUCache<CachedResponse>;
-  private tagIndex: Map<string, Set<string>>;
-  private keyTags: Map<string, Set<string>>;
-  constructor(maxSize?: number);
-  get(key: string): Promise<CachedResponse | null>;
-  set(key: string, response: CachedResponse): Promise<void>;
-  delete(key: string): boolean;
-  invalidateByTags(tags: string[]): number;
-  clear(): void;
-  getStats(): ReturnType<LRUCache<CachedResponse>['getStats']> & { totalTags: number, totalKeyTagMappings: number };
-}

package/dist/routing/route-throttling.d.ts

@@ -1,112 +0,0 @@
-import { LRUCache } from '../cache/lru-cache';
-import type { EnhancedRequest, MiddlewareHandler, ThrottlePattern } from '../types';
-/**
- * Create rate limiting middleware
- */
-export declare function createRateLimitMiddleware(config: ThrottleConfig, name?: string): MiddlewareHandler;
-/**
- * Parse throttle string (Laravel-style) with enhanced time unit support
- * Examples: '60,1' -> 60 requests per 1 minute
- *          '100,30s' -> 100 requests per 30 seconds
- *          '1000,1h' -> 1000 requests per 1 hour
- *          '60' -> 60 requests per 1 minute (default)
- */
-export declare function parseThrottleString(throttleStr: ThrottlePattern): ThrottleConfig;
-/**
- * Global rate limit registry instance
- */
-export declare const rateLimitRegistry: RateLimitRegistry;
-/**
- * Factory functions for common rate limiting scenarios
- */
-export declare const ThrottleFactory: {
-  /**
-   * API rate limiting (60 requests per minute)
-   */
-  api: (maxAttempts: number?, windowMinutes: number?) => any;
-  /**
-   * Authentication rate limiting (5 attempts per 15 minutes)
-   */
-  auth: () => any;
-  /**
-   * Upload rate limiting (10 uploads per hour)
-   */
-  upload: () => any;
-  /**
-   * Search rate limiting (100 searches per 10 minutes)
-   */
-  search: () => any;
-  /**
-   * Per-user rate limiting
-   */
-  perUser: (maxAttempts: number, windowMinutes: number) => any;
-  /**
-   * Per-IP rate limiting
-   */
-  perIP: (maxAttempts: number, windowMinutes: number) => any;
-  /**
-   * Global rate limiting (shared across all users)
-   */
-  global: (maxAttempts: number, windowMinutes: number) => any
-};
-/**
- * Rate limit utilities
- */
-export declare const RateLimitUtils: {
-  /**
-   * Create throttle middleware from string (Laravel-style)
-   */
-  fromString: (throttleStr: string, name?: string) => any;
-  /**
-   * Get rate limit info for a request without incrementing
-   */
-  getInfo: (req: EnhancedRequest, config: ThrottleConfig) => Promise<RateLimitInfo>;
-  /**
-   * Reset rate limit for a specific key
-   */
-  reset: (limiterName: string, key: string) => any
-};
-/**
- * Throttle configuration for rate limiting
- */
-export declare interface ThrottleConfig {
-  maxAttempts: number
-  windowMs: number
-  keyGenerator?: (req: EnhancedRequest) => string
-  skipIf?: (req: EnhancedRequest) => boolean
-  onLimitReached?: (req: EnhancedRequest, info: RateLimitInfo) => Response
-  headers?: boolean
-  maxRequests?: number
-}
-/**
- * Rate limit information
- */
-export declare interface RateLimitInfo {
-  totalHits: number
-  totalHits24h?: number
-  resetTime: Date
-  remaining: number
-  limit: number
-  windowMs: number
-}
-/**
- * Rate limiter implementation
- */
-export declare class RateLimiter {
-  private cache: LRUCache<RateLimitEntry>;
-  private config: ThrottleConfig;
-  constructor(config: ThrottleConfig, cacheSize?: number);
-  checkLimit(req: EnhancedRequest): Promise<{ allowed: boolean, info: RateLimitInfo }>;
-  private generateKey(req: EnhancedRequest): string;
-  private getClientIP(req: EnhancedRequest): string;
-  getStats(): ReturnType<LRUCache<RateLimitEntry>['getStats']> & { config: { maxAttempts: number, windowMs: number } };
-}
-/**
- * Global rate limiters registry
- */
-export declare class RateLimitRegistry {
-  private limiters: any;
-  register(name: string, config: ThrottleConfig): RateLimiter;
-  get(name: string): RateLimiter | undefined;
-  getOrCreate(name: string, config: ThrottleConfig): RateLimiter;
-}