@grupodiariodaregiao/bunstone 0.3.3 → 0.3.4

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export * from "./lib/adapters/upload-adapter";
 export * from "./lib/app-startup";
 export * from "./lib/components/layout";
 export * from "./lib/controller";
+export * from "./lib/ratelimit";
 export * from "./lib/cqrs/command-bus";
 export * from "./lib/cqrs/cqrs-module";
 export * from "./lib/cqrs/decorators/command-handler.decorator";
@@ -14,7 +15,6 @@ export * from "./lib/cqrs/decorators/event-handler.decorator";
 export * from "./lib/cqrs/decorators/query-handler.decorator";
 export * from "./lib/cqrs/decorators/saga.decorator";
 export * from "./lib/cqrs/event-bus";
-export { map, ofType } from "./lib/cqrs/event-bus";
 export * from "./lib/cqrs/interfaces/command.interface";
 export * from "./lib/cqrs/interfaces/event.interface";
 export * from "./lib/cqrs/interfaces/query.interface";

package/dist/index.js

@@ -32209,7 +32209,7 @@ var require_node_cron = __commonJS((exports) => {
 });
 
 // index.ts
-var import_reflect_metadata24 = __toESM(require_Reflect(), 1);
+var import_reflect_metadata25 = __toESM(require_Reflect(), 1);
 
 // lib/adapters/cache-adapter.ts
 var {RedisClient, redis } = globalThis.Bun;
@@ -42871,6 +42871,14 @@ var MapProvidersWithBullMq = {
   }
 };
 
+// lib/ratelimit/constants.ts
+var RATELIMIT_METADATA_KEY = "dip:ratelimit";
+var RATELIMIT_CONTROLLER_METADATA_KEY = "dip:ratelimit:controller";
+var DEFAULT_RATELIMIT_CONFIG = {
+  max: 100,
+  windowMs: 60000
+};
+
 // lib/schedule/cron/mappers/map-providers-with-cron.ts
 var MapProvidersWithCron = {
   execute(providers = []) {
@@ -43082,21 +43090,24 @@ function mapControllers(controllers = []) {
   const controllersMap = new Map;
   for (const controller of controllers) {
     controllersMap.set(controller, []);
-    for (const controllerSymbol of Object.getOwnPropertySymbols(controller)) {
-      const controllerPathname = Reflect.getOwnMetadata("dip:controller:pathname", controller);
-      const controllerGuard = Reflect.getMetadata("dip:guard", controller);
-      const controllerMethods = controller[controllerSymbol];
-      controllerMethods.forEach((cm) => {
-        const pathname = `${controllerPathname === "/" ? "" : controllerPathname}${cm.pathname}`;
-        const methodGuard = Reflect.getMetadata("dip:guard", controller.prototype, cm.methodName);
-        controllersMap.get(controller)?.push({
-          httpMethod: cm.httpMethod,
-          pathname,
-          methodName: cm.methodName,
-          guard: methodGuard || controllerGuard
-        });
+    const controllerRateLimit = Reflect.getMetadata(RATELIMIT_CONTROLLER_METADATA_KEY, controller);
+    const controllerPathname = Reflect.getOwnMetadata("dip:controller:pathname", controller);
+    const controllerGuard = Reflect.getMetadata("dip:guard", controller);
+    const methodsSymbol = Symbol.for("dip:controller:http-methods");
+    const controllerMethods = controller[methodsSymbol] || [];
+    controllerMethods.forEach((cm) => {
+      const pathname = `${controllerPathname === "/" ? "" : controllerPathname}${cm.pathname}`;
+      const methodGuard = Reflect.getMetadata("dip:guard", controller.prototype, cm.methodName);
+      const methodRateLimit = Reflect.getMetadata(RATELIMIT_METADATA_KEY, controller.prototype[cm.methodName]);
+      const effectiveRateLimit = methodRateLimit || controllerRateLimit;
+      controllersMap.get(controller)?.push({
+        httpMethod: cm.httpMethod,
+        pathname,
+        methodName: cm.methodName,
+        guard: methodGuard || controllerGuard,
+        rateLimit: effectiveRateLimit
       });
-    }
+    });
   }
   return controllersMap;
 }
@@ -102964,8 +102975,9 @@ class QueueService {
     return await queue2.add(jobName, data, opts);
   }
   getQueue(queueName) {
-    if (this.queues.has(queueName)) {
-      return this.queues.get(queueName);
+    const existingQueue = this.queues.get(queueName);
+    if (existingQueue) {
+      return existingQueue;
     }
     if (!QueueService.redisOptions) {
       this.logger.error(`Redis options not set for BullMQ. Ensure BullMqModule.register() is called in your AppModule imports.`);
@@ -103335,6 +103347,160 @@ function ApiHeaders(headers) {
   };
 }
 
+// lib/ratelimit/storage/memory.storage.ts
+class MemoryStorage {
+  storage = new Map;
+  cleanupInterval = null;
+  constructor() {
+    this.cleanupInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [key, entry] of this.storage.entries()) {
+        if (entry.resetTime <= now) {
+          this.storage.delete(key);
+        }
+      }
+    }, 5 * 60 * 1000);
+  }
+  increment(key, windowMs) {
+    const now = Date.now();
+    const entry = this.storage.get(key);
+    if (!entry || entry.resetTime <= now) {
+      const newEntry = {
+        count: 1,
+        resetTime: now + windowMs
+      };
+      this.storage.set(key, newEntry);
+      return {
+        totalHits: 1,
+        remaining: Infinity,
+        resetTime: newEntry.resetTime
+      };
+    }
+    entry.count++;
+    return {
+      totalHits: entry.count,
+      remaining: Infinity,
+      resetTime: entry.resetTime
+    };
+  }
+  decrement(key) {
+    const entry = this.storage.get(key);
+    if (entry && entry.count > 0) {
+      entry.count--;
+    }
+  }
+  resetKey(key) {
+    this.storage.delete(key);
+  }
+  close() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.storage.clear();
+  }
+}
+
+// lib/ratelimit/ratelimit.service.ts
+class RateLimitExceededException extends Error {
+  limit;
+  resetTime;
+  constructor(limit, resetTime) {
+    super(`Rate limit exceeded. Limit: ${limit}. Retry after ${new Date(resetTime).toISOString()}`);
+    this.limit = limit;
+    this.resetTime = resetTime;
+    this.name = "RateLimitExceededException";
+  }
+}
+
+class RateLimitService {
+  defaultStorage = new MemoryStorage;
+  async process(req, config) {
+    if (config.skip?.(req)) {
+      return this.createSkipResult(config.max);
+    }
+    if (config.skipHeader && req.headers[config.skipHeader.toLowerCase()]) {
+      return this.createSkipResult(config.max);
+    }
+    const storage = config.storage || this.defaultStorage;
+    const key = this.generateKey(req, config.keyGenerator);
+    const info = await storage.increment(key, config.windowMs);
+    info.remaining = Math.max(0, config.max - info.totalHits);
+    const allowed = info.totalHits <= config.max;
+    const headers = this.generateHeaders(info, config.max, allowed);
+    return {
+      allowed,
+      headers,
+      info
+    };
+  }
+  async decrement(req, config) {
+    const storage = config.storage || this.defaultStorage;
+    const key = this.generateKey(req, config.keyGenerator);
+    await storage.decrement(key);
+  }
+  generateKey(req, keyGenerator) {
+    if (keyGenerator) {
+      return keyGenerator(req);
+    }
+    const ip = this.extractIp(req);
+    const method = req.request?.method || req.method || "GET";
+    const path3 = req.request?.url || req.path || req.url || "/";
+    return `${ip}:${method}:${path3}`;
+  }
+  extractIp(req) {
+    const forwarded = req.headers["x-forwarded-for"];
+    if (forwarded && typeof forwarded === "string") {
+      const firstIp = forwarded.split(",")[0];
+      if (firstIp) {
+        return firstIp.trim();
+      }
+    }
+    const realIp = req.headers["x-real-ip"];
+    if (realIp && typeof realIp === "string") {
+      return realIp;
+    }
+    const ip = req.ip || req.request?.ip;
+    if (ip) {
+      return ip;
+    }
+    return "unknown";
+  }
+  generateHeaders(info, max, allowed) {
+    const headers = {
+      "X-RateLimit-Limit": max.toString(),
+      "X-RateLimit-Remaining": info.remaining.toString(),
+      "X-RateLimit-Reset": Math.ceil(info.resetTime / 1000).toString()
+    };
+    if (!allowed) {
+      const retryAfterSeconds = Math.ceil((info.resetTime - Date.now()) / 1000);
+      headers["Retry-After"] = Math.max(0, retryAfterSeconds).toString();
+    }
+    return headers;
+  }
+  createSkipResult(max) {
+    return {
+      allowed: true,
+      headers: {
+        "X-RateLimit-Limit": max.toString(),
+        "X-RateLimit-Remaining": max.toString(),
+        "X-RateLimit-Reset": "0"
+      },
+      info: {
+        totalHits: 0,
+        remaining: max,
+        resetTime: Date.now()
+      }
+    };
+  }
+  getDefaultStorage() {
+    return this.defaultStorage;
+  }
+}
+RateLimitService = __legacyDecorateClassTS([
+  Injectable()
+], RateLimitService);
+
 // lib/render.ts
 var import_reflect_metadata14 = __toESM(require_Reflect(), 1);
 var RENDER_METADATA = "dip:render:component";
@@ -103356,6 +103522,8 @@ class AppStartup {
   static logger = new Logger(AppStartup.name);
   static registeredSagas = new WeakSet;
   static viewBundles = new Map;
+  static globalRateLimitConfig;
+  static rateLimitService = new RateLimitService;
   static async create(module, options) {
     try {
       AppStartup.elysia = new Elysia;
@@ -103417,6 +103585,7 @@ class AppStartup {
           documentation: options.swagger.documentation
         }));
       }
+      AppStartup.globalRateLimitConfig = options?.rateLimit;
       AppStartup.registerModules(module);
       return {
         listen: AppStartup.listen,
@@ -103627,6 +103796,23 @@ if (document.readyState === 'loading') {
             } : undefined
           };
         });
+        const hasRateLimit = method.rateLimit || AppStartup.globalRateLimitConfig?.enabled !== false && AppStartup.globalRateLimitConfig;
+        if (hasRateLimit) {
+          responses["429"] = {
+            description: "Too Many Requests - Rate limit exceeded",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    status: { type: "number" },
+                    message: { type: "string" }
+                  }
+                }
+              }
+            }
+          };
+        }
         const controllerHeaders = Reflect.getMetadata(API_HEADERS_METADATA, controllerInstance) || [];
         const methodHeaders = Reflect.getMetadata(API_HEADERS_METADATA, controllerInstance.prototype, method.methodName) || [];
         const allHeaders = [...controllerHeaders, ...methodHeaders];
@@ -103647,6 +103833,7 @@ if (document.readyState === 'loading') {
           const guardDependencies = resolveDependencies(guardParamsTypes, injectables);
           guardInstance = new method.guard(...guardDependencies);
         }
+        const effectiveRateLimit = AppStartup.buildEffectiveRateLimit(method.rateLimit);
         AppStartup.elysia[httpMethod](method.pathname, (req) => AppStartup.executeControllerMethod(req, controller, method.methodName), {
           body: bodySchema,
           query: querySchema,
@@ -103658,7 +103845,24 @@ if (document.readyState === 'loading') {
             responses,
             parameters
           },
-          beforeHandle(req) {
+          async beforeHandle(req) {
+            if (effectiveRateLimit) {
+              const result = await AppStartup.rateLimitService.process(req, effectiveRateLimit);
+              if (req.set?.headers) {
+                Object.entries(result.headers).forEach(([key, value]) => {
+                  if (value !== undefined) {
+                    req.set.headers[key] = value;
+                  }
+                });
+              }
+              if (!result.allowed) {
+                req.set.status = 429;
+                return {
+                  status: 429,
+                  message: effectiveRateLimit.message || "Too many requests, please try again later."
+                };
+              }
+            }
             if (!guardInstance)
               return;
             const isValid = guardInstance.validate(req);
@@ -103678,6 +103882,37 @@ if (document.readyState === 'loading') {
       }
     }
   }
+  static buildEffectiveRateLimit(methodRateLimit) {
+    const global2 = AppStartup.globalRateLimitConfig;
+    if (methodRateLimit) {
+      if (methodRateLimit.enabled === false) {
+        return;
+      }
+      return {
+        enabled: true,
+        max: methodRateLimit.max ?? global2?.max ?? 100,
+        windowMs: methodRateLimit.windowMs ?? global2?.windowMs ?? 60000,
+        storage: methodRateLimit.storage ?? global2?.storage,
+        keyGenerator: methodRateLimit.keyGenerator ?? global2?.keyGenerator,
+        skipHeader: methodRateLimit.skipHeader ?? global2?.skipHeader,
+        skip: methodRateLimit.skip ?? global2?.skip,
+        message: methodRateLimit.message ?? global2?.message
+      };
+    }
+    if (global2?.enabled !== false && global2) {
+      return {
+        enabled: true,
+        max: global2.max ?? 100,
+        windowMs: global2.windowMs ?? 60000,
+        storage: global2.storage,
+        keyGenerator: global2.keyGenerator,
+        skipHeader: global2.skipHeader,
+        skip: global2.skip,
+        message: global2.message
+      };
+    }
+    return;
+  }
   static registerTimeouts(module) {
     const providersTimeouts = Reflect.getMetadata("dip:timeouts", module);
     if (!providersTimeouts) {
@@ -103718,7 +103953,7 @@ if (document.readyState === 'loading') {
       return;
     }
     const injectables = Reflect.getMetadata("dip:injectables", module);
-    const queueService = injectables?.get(QueueService);
+    const _queueService = injectables?.get(QueueService);
     const redisOptions = QueueService.redisOptions;
     for (const item of providersBullMq.entries()) {
       const [providerClass, methods] = item;
@@ -103849,6 +104084,90 @@ function Controller(pathname = "/") {
     Reflect.defineMetadata("dip:controller:pathname", pathname, target2);
   };
 }
+// lib/ratelimit/ratelimit.decorator.ts
+var import_reflect_metadata17 = __toESM(require_Reflect(), 1);
+function RateLimit(options = {}) {
+  return (target2, _propertyKey, descriptor) => {
+    const config = {
+      enabled: options.enabled ?? true,
+      max: options.max ?? 100,
+      windowMs: options.windowMs ?? 60000,
+      message: options.message,
+      storage: options.storage,
+      keyGenerator: options.keyGenerator,
+      skipHeader: options.skipHeader,
+      skip: options.skip
+    };
+    if (descriptor) {
+      Reflect.defineMetadata(RATELIMIT_METADATA_KEY, config, descriptor.value);
+      return descriptor;
+    }
+    Reflect.defineMetadata(RATELIMIT_CONTROLLER_METADATA_KEY, config, target2);
+    return target2;
+  };
+}
+// lib/ratelimit/storage/redis.storage.ts
+class RedisStorage {
+  redisClient;
+  prefix = "ratelimit:";
+  constructor(redisClient, prefix) {
+    this.redisClient = redisClient;
+    if (prefix) {
+      this.prefix = prefix;
+    }
+  }
+  getKey(key) {
+    return `${this.prefix}${key}`;
+  }
+  async increment(key, windowMs) {
+    const fullKey = this.getKey(key);
+    const now = Date.now();
+    const multi = this.redisClient.multi();
+    multi.incr(fullKey);
+    multi.pexpire(fullKey, windowMs);
+    multi.pttl(fullKey);
+    const result = await multi.exec();
+    if (!result) {
+      throw new Error("Failed to execute Redis transaction");
+    }
+    const results = result[1];
+    if (!results || !Array.isArray(results)) {
+      throw new Error("Invalid Redis transaction response");
+    }
+    const countResult = results[0];
+    const ttlResult = results[2];
+    const incrError = countResult[0];
+    const count = countResult[1];
+    if (incrError) {
+      throw incrError;
+    }
+    const ttl = ttlResult?.[1] ?? -1;
+    let resetTime;
+    if (typeof ttl === "number" && ttl > 0) {
+      resetTime = now + ttl;
+    } else {
+      resetTime = now + windowMs;
+    }
+    return {
+      totalHits: typeof count === "string" ? Number.parseInt(count, 10) : count || 1,
+      remaining: Infinity,
+      resetTime
+    };
+  }
+  async decrement(key) {
+    const fullKey = this.getKey(key);
+    await this.redisClient.decr(fullKey);
+  }
+  async resetKey(key) {
+    const fullKey = this.getKey(key);
+    await this.redisClient.del(fullKey);
+  }
+  async close() {
+    if (this.redisClient.quit) {
+      await this.redisClient.quit();
+    }
+  }
+}
 // lib/cqrs/cqrs-module.ts
 class CqrsModule {
 }
@@ -103923,7 +104242,7 @@ BullMqModule = __legacyDecorateClassTS([
   })
 ], BullMqModule);
 // lib/bullmq/decorators/processor.decorator.ts
-var import_reflect_metadata17 = __toESM(require_Reflect(), 1);
+var import_reflect_metadata18 = __toESM(require_Reflect(), 1);
 function Processor(options) {
   const processorOptions = typeof options === "string" ? { queueName: options } : options;
   return (target2) => {
@@ -103932,7 +104251,7 @@ function Processor(options) {
   };
 }
 // lib/bullmq/decorators/process.decorator.ts
-var import_reflect_metadata18 = __toESM(require_Reflect(), 1);
+var import_reflect_metadata19 = __toESM(require_Reflect(), 1);
 function Process(name3) {
   return (target2, propertyKey, _descriptor) => {
     const sym = Symbol.for("dip:providers:bullmq");
@@ -103946,7 +104265,7 @@ function Process(name3) {
   };
 }
 // lib/guard.ts
-var import_reflect_metadata19 = __toESM(require_Reflect(), 1);
+var import_reflect_metadata20 = __toESM(require_Reflect(), 1);
 
 // lib/utils/is-class.ts
 function isClass(fn3) {
@@ -104018,7 +104337,7 @@ function Jwt() {
   };
 }
 // lib/jwt/jwt-module.ts
-var import_reflect_metadata20 = __toESM(require_Reflect(), 1);
+var import_reflect_metadata21 = __toESM(require_Reflect(), 1);
 
 class JwtModule {
   static options;
@@ -104034,7 +104353,7 @@ class JwtModule {
   }
 }
 // lib/schedule/cron/cron.ts
-var import_reflect_metadata21 = __toESM(require_Reflect(), 1);
+var import_reflect_metadata22 = __toESM(require_Reflect(), 1);
 function Cron(expression) {
   if (!expression) {
     throw new Error("Invalid cron expression.");
@@ -104054,7 +104373,7 @@ function Cron(expression) {
   };
 }
 // lib/schedule/timeout/timeout.ts
-var import_reflect_metadata22 = __toESM(require_Reflect(), 1);
+var import_reflect_metadata23 = __toESM(require_Reflect(), 1);
 function Timeout(delay2) {
   if (!delay2 || delay2 < 0) {
     throw new Error("Delay must be a positive number.");
@@ -104074,7 +104393,7 @@ function Timeout(delay2) {
   };
 }
 // lib/testing/testing-module-builder.ts
-var import_reflect_metadata23 = __toESM(require_Reflect(), 1);
+var import_reflect_metadata24 = __toESM(require_Reflect(), 1);
 
 // lib/testing/test-app.ts
 class TestApp {
@@ -104229,7 +104548,13 @@ export {
   SAGA_METADATA,
   Request2 as Request,
   Render,
+  RedisStorage,
+  RateLimitService,
+  RateLimitExceededException,
+  RateLimit,
   RENDER_METADATA,
+  RATELIMIT_METADATA_KEY,
+  RATELIMIT_CONTROLLER_METADATA_KEY,
   QueueService,
   QueryHandler,
   QueryBus,
@@ -104248,6 +104573,7 @@ export {
   NoContentResponse,
   ModuleInitializationError,
   Module,
+  MemoryStorage,
   Logger,
   LogLevel,
   Layout,
@@ -104274,6 +104600,7 @@ export {
   DependencyResolutionError,
   Delete,
   DatabaseError,
+  DEFAULT_RATELIMIT_CONFIG,
   Cron,
   CreatedResponse,
   CqrsModule,

package/dist/lib/app-startup.d.ts

@@ -10,6 +10,8 @@ export declare class AppStartup {
     private static readonly logger;
     private static readonly registeredSagas;
     private static readonly viewBundles;
+    private static globalRateLimitConfig;
+    private static rateLimitService;
     /**
      * Initializes the application from a root module.
      *
@@ -68,6 +70,10 @@ export declare class AppStartup {
     private static executeControllerMethod;
     private static registerModules;
     private static registerRoutes;
+    /**
+     * Builds effective rate limit configuration by merging global config with method config
+     */
+    private static buildEffectiveRateLimit;
     private static registerTimeouts;
     private static registerCronJobs;
     private static registerBullMqWorkers;

package/dist/lib/ratelimit/constants.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Metadados utilizados pelo sistema de rate limit
+ */
+/** Chave de metadado para configuração de rate limit em métodos */
+export declare const RATELIMIT_METADATA_KEY = "dip:ratelimit";
+/** Chave de metadado para configuração de rate limit em controllers */
+export declare const RATELIMIT_CONTROLLER_METADATA_KEY = "dip:ratelimit:controller";
+/** Configurações padrão de rate limit */
+export declare const DEFAULT_RATELIMIT_CONFIG: {
+    max: number;
+    windowMs: number;
+};

package/dist/lib/ratelimit/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./constants";
+export * from "./interfaces/storage.interface";
+export * from "./ratelimit.decorator";
+export * from "./ratelimit.service";
+export * from "./storage/memory.storage";
+export * from "./storage/redis.storage";

package/dist/lib/ratelimit/interfaces/storage.interface.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Interface que define o contrato para storage de rate limiting.
+ * Suporta implementações em memória e Redis.
+ */
+/**
+ * Informações de consumo de rate limit
+ */
+export interface RateLimitInfo {
+    /** Total de requisições permitidas no window */
+    totalHits: number;
+    /** Quantidade de requisições restantes */
+    remaining: number;
+    /** Timestamp (ms) quando o window reseta */
+    resetTime: number;
+}
+/**
+ * Interface base para storage de rate limit
+ */
+export interface RateLimitStorage {
+    /**
+     * Incrementa o contador para uma chave específica
+     * @param key Chave única (IP + endpoint)
+     * @param windowMs Janela de tempo em milissegundos
+     * @returns Informações atualizadas de rate limit
+     */
+    increment(key: string, windowMs: number): Promise<RateLimitInfo> | RateLimitInfo;
+    /**
+     * Decrementa o contador (útil quando requisição é rejeitada antes do processamento)
+     * @param key Chave única
+     */
+    decrement(key: string): Promise<void> | void;
+    /**
+     * Reseta o contador para uma chave específica
+     * @param key Chave única
+     */
+    resetKey(key: string): Promise<void> | void;
+    /**
+     * Fecha a conexão (para storage externo como Redis)
+     */
+    close?(): Promise<void> | void;
+}

package/dist/lib/ratelimit/ratelimit.decorator.d.ts

@@ -0,0 +1,52 @@
+import "reflect-metadata";
+import type { HttpRequest } from "../types/http-request";
+import type { RateLimitStorage } from "./interfaces/storage.interface";
+import type { RateLimitConfig } from "./ratelimit.service";
+/**
+ * Opções para o decorator @RateLimit
+ */
+export interface RateLimitOptions {
+    /** Se o rate limit está habilitado (padrão: true) */
+    enabled?: boolean;
+    /** Máximo de requisições permitidas na janela de tempo (padrão: 100) */
+    max?: number;
+    /** Janela de tempo em milissegundos (padrão: 60000 = 1 minuto) */
+    windowMs?: number;
+    /** Mensagem de erro customizada quando excede o limite */
+    message?: string;
+    /** Storage customizado (padrão: MemoryStorage) */
+    storage?: RateLimitStorage;
+    /** Função para extrair a chave de identificação */
+    keyGenerator?: (req: HttpRequest) => string;
+    /** Header que permite pular o rate limit */
+    skipHeader?: string;
+    /** Função que determina se deve pular o rate limit */
+    skip?: (req: HttpRequest) => boolean;
+}
+/**
+ * Configuração interna completa de rate limit
+ */
+export interface RateLimitMetadata extends RateLimitConfig {
+    enabled: boolean;
+}
+/**
+ * Decorator para aplicar rate limiting em métodos de controller ou em todo o controller.
+ *
+ * @param options Opções de configuração do rate limit
+ *
+ * @example
+ * ```typescript
+ * // No controller (afeta todos os métodos)
+ * @RateLimit({ max: 50, windowMs: 60000 })
+ * @Controller('api')
+ * class MyController {
+ *   // No método (sobrescreve o do controller)
+ *   @Get('data')
+ *   @RateLimit({ max: 100, windowMs: 60000 })
+ *   getData() {
+ *     return { data: [] };
+ *   }
+ * }
+ * ```
+ */
+export declare function RateLimit(options?: RateLimitOptions): any;