shokupan 0.2.0 → 0.4.4

package/README.md

@@ -1,33 +1,35 @@
 # Shokupan 🍞
 
-> A low-lift modern web framework for Bun
+> A delightful, type-safe web framework for Bun
 
-Shokupan is a high-performance, feature-rich web framework built specifically for Bun. It combines the familiarity of Express.js with modern NestJS-style architecture (Dependency Injection, Controllers) and seamless compatibility with the vast ecosystem of Express plugins — all while maintaining exceptional performance and built-in OpenAPI support.
+**Built for Developer Experience**
+Shokupan is designed to make building APIs delightful again. With zero-config defaults, instant startup times, and full type safety out of the box, you can focus on building your product, not configuring your framework.
 
 ### Note: Shokupan is still in alpha and is not guaranteed to be stable. Please use with caution. We will be adding more features and APIs in the future. Please file an issue if you find any bugs or have suggestions for improvement.
 
 ## ✨ Features
 
-- 🚀 **Built for Bun** - Native [Bun](https://bun.sh/) performance with optimized routing
-- 🎯 **TypeScript First** - Full type safety with decorators and generics
-- 📝 **Auto OpenAPI** - Generate [OpenAPI](https://www.openapis.org/) specs automatically from routes
-- 🔌 **Rich Plugin System** - CORS, Sessions, Auth, Validation, Rate Limiting, and more
-- 🌐 **Flexible Routing** - Express-style routes or decorator-based controllers
-- 🔀 **Express Compatible** - Works with [Express](https://expressjs.com/) middleware patterns
-- 📊 **Built-in Telemetry** - [OpenTelemetry](https://opentelemetry.io/) instrumentation out of the box
-- 🔐 **OAuth2 Support** - GitHub, Google, Microsoft, Apple, Auth0, Okta
-- ✅ **Multi-validator Support** - Zod, Ajv, TypeBox, Valibot
-- 📚 **OpenAPI Docs** - Beautiful OpenAPI documentation with [Scalar](https://scalar.dev/)
-- ⏩ **Short shift** - Very simple migration from [Express](https://expressjs.com/) or [NestJS](https://nestjs.com/) to Shokupan
+- 🎯 **TypeScript First** - End-to-end type safety with decorators and generics. No manual types needed.
+- 🛠️ **Zero Config** - Works effectively out of the box. No complex setup or boilerplate.
+- 🚀 **Built for Bun** - Native [Bun](https://bun.sh/) performance with instant startup.
+- 🔍 **Debug Dashboard** - Visual inspector for your routes, middleware, and request flow.
+- 📝 **Auto OpenAPI** - Generate [OpenAPI](https://www.openapis.org/) specs automatically from routes.
+- 🔌 **Rich Plugin System** - CORS, Sessions, Auth, Validation, Rate Limiting, and more.
+- 🌐 **Flexible Routing** - Express-style routes or decorator-based controllers.
+- 🔀 **Express Compatible** - Works with [Express](https://expressjs.com/) middleware patterns.
+- 📊 **Built-in Telemetry** - [OpenTelemetry](https://opentelemetry.io/) instrumentation out of the box.
+- 🔐 **OAuth2 Support** - GitHub, Google, Microsoft, Apple, Auth0, Okta.
+- ✅ **Multi-validator Support** - Zod, Ajv, TypeBox, Valibot.
+- 📚 **OpenAPI Docs** - Beautiful OpenAPI documentation with [Scalar](https://scalar.dev/).
+- ⏩ **Short shift** - Very simple migration from [Express](https://expressjs.com/) or [NestJS](https://nestjs.com/) to Shokupan.
 
-## 📦 Installation
+![Shokupan Debug Dashboard](docs/src/assets/debug_dashboard_overview.png)
 
-```bash
-bun add shokupan
-```
 
 ## 🚀 Quick Start
 
+> Bun and TypeScript are recommended for Shokupan, though it also supports Node.js and standard JavaScript.
+
 ```typescript
 import { Shokupan } from 'shokupan';
 
@@ -829,6 +831,119 @@ app.mount('/docs', new ScalarPlugin({
 
 The Scalar plugin automatically generates OpenAPI documentation from your routes and controllers!
 
+### Proxy
+
+Create a reverse proxy to forward requests to another server:
+
+```typescript
+import { Proxy } from 'shokupan';
+
+app.use('/api/v1', Proxy({
+    target: 'https://api.example.com',
+    changeOrigin: true,
+    pathRewrite: (path) => path.replace('/api/v1', ''),
+    headers: {
+        'X-Custom-Header': 'Proxy'
+    }
+}));
+
+// Proxy WebSockets
+app.use('/socket', Proxy({
+    target: 'ws://ws.example.com',
+    ws: true
+}));
+```
+
+### OpenAPI Validator
+
+Validate incoming requests against your generated OpenAPI specification:
+
+```typescript
+import { enableOpenApiValidation } from 'shokupan';
+
+const app = new Shokupan({ enableOpenApiGen: true });
+
+// Enable validation middleware
+// This validates Body, Query, Params, and Headers against your OpenAPI definitions
+enableOpenApiValidation(app);
+
+app.post('/users', {
+    parameters: [
+        { name: 'apiKey', in: 'header', required: true, schema: { type: 'string' } }
+    ],
+    requestBody: {
+        content: {
+            'application/json': {
+                schema: {
+                    type: 'object',
+                    required: ['name'],
+                    properties: {
+                        name: { type: 'string', minLength: 3 }
+                    }
+                }
+            }
+        }
+    }
+}, (ctx) => {
+    return { success: true };
+});
+
+// Invalid requests will throw a ValidationError (400 Bad Request)
+```
+
+### Idempotency
+
+Ensure that multiple identical requests do not result in different outcomes (e.g., duplicate payments). This middleware caches the response of the first request and returns it for subsequent requests with the same idempotency key.
+
+```typescript
+import { Idempotency } from 'shokupan';
+
+app.post('/payments', 
+    Idempotency({
+        header: 'Idempotency-Key', // default
+        ttl: 24 * 60 * 60 * 1000   // default 24h
+    }),
+    async (ctx) => {
+        // Process payment...
+        return { status: 'charged' };
+    }
+);
+```
+
+### Failed Request Recorder
+
+Automatically record failed requests (500s) for debugging and replay purposes.
+
+```typescript
+import { FailedRequestRecorder } from 'shokupan';
+
+app.use(FailedRequestRecorder({
+    maxCapacity: 1000,
+    ttl: 86400000 // 1 day
+}));
+```
+
+This works great when combined with the Debug Dashboard.
+
+### Debug Dashboard
+
+A visual dashboard to inspect your application, view metrics, analyze the middleware graph, and replay failed requests.
+
+```typescript
+import { DebugDashboard } from 'shokupan/plugins/debugview';
+
+// Mount the dashboard
+app.mount('/debug', new DebugDashboard({
+    retentionMs: 2 * 60 * 60 * 1000, // Keep 2 hours of logs
+    getRequestHeaders: () => ({
+        'Authorization': 'Bearer ...' // Headers to using when replaying requests and accessing data APIs
+    })
+}));
+
+// Available at http://localhost:3000/debug
+```
+
+
 ## 🚀 Advanced Features
 
 ### Dependency Injection
@@ -999,8 +1114,40 @@ provider.addSpanProcessor(
 provider.register();
 ```
 
+### Server Factory (Node.js & Deno)
+
+Run Shokupan on Node.js or Deno using the server adapter:
+
+```typescript
+import { Shokupan, createHttpServer } from 'shokupan';
+
+const app = new Shokupan({
+    // Use Node.js http module
+    serverFactory: createHttpServer()
+});
+
+app.get('/', () => ({ message: 'Running on Node!' }));
+
+app.listen(3000);
+```
+
+### Automatic Backpressure
+
+Protect your server from overload by shedding load when CPU usage is high:
+
+```typescript
+const app = new Shokupan({
+    // Monitor CPU and reject requests when usage > 80%
+    autoBackpressureFeedback: true,
+    autoBackpressureLevel: 80 
+});
+```
+
+When the threshold is reached, the server will return `429 Too Many Requests`.
+
 ## 📦 Migration Guides
 
+
 ### From Express
 
 Shokupan is designed to feel familiar to Express developers. Here's how to migrate:
@@ -1397,6 +1544,10 @@ app.use(useExpress(compression()));
 ## 🧪 Testing
 
 Shokupan applications are easy to test using Bun's built-in test runner.
+It can directly pass requests to the application or a router without requiring the 
+server to fully start, bind to a port or listen for connections. This makes mocking 
+the server unnecessary and allows for faster and more reliable testing. Additionally
+you can directly test authenticated endpoints without the need for a session or cookie.
 
 ```typescript
 import { describe, it, expect } from 'bun:test';
@@ -1427,13 +1578,13 @@ Since Shokupan is built on Bun, deployment is straightforward.
 ### Using Bun
 
 ```bash
-bun run src/index.ts
+bun run src/main.ts
 ```
 
 ### Docker
 
 ```dockerfile
-FROM oven/bun:1
+FROM oven/bun:1-alpine
 
 WORKDIR /app
 
@@ -1442,7 +1593,7 @@ RUN bun install --production
 
 EXPOSE 3000
 
-CMD ["bun", "run", "src/index.ts"]
+CMD ["bun", "run", "src/main.ts"]
 ```
 
 ## 🛠️ CLI Tools
@@ -1530,6 +1681,14 @@ const app = new Shokupan(config?: ShokupanConfig);
 - `hostname?: string` - Hostname (default: "localhost")
 - `development?: boolean` - Development mode (default: auto-detect)
 - `enableAsyncLocalStorage?: boolean` - Enable async context tracking
+- `enableTracing?: boolean` - Enable OpenTelemetry tracing
+- `enableOpenApiGen?: boolean` - Enable OpenAPI spec generation (default: true)
+- `controllersOnly?: boolean` - If true, only allows controllers, disabling app.get/post/etc (default: false)
+- `requestTimeout?: number` - Global request timeout (ms)
+- `readTimeout?: number` - Request body read timeout (ms)
+- `serverFactory?: ServerFactory` - Custom server factory (for Node.js/Deno support)
+- `autoBackpressureFeedback?: boolean` - Enable automatic load shedding based on CPU usage
+- `autoBackpressureLevel?: number` - CPU usage % threshold for backpressure (default: 60)
 - `logger?: Logger` - Custom logger instance
 
 **Methods:**
@@ -1551,7 +1710,13 @@ const app = new Shokupan(config?: ShokupanConfig);
 
 ### ShokupanRouter Class
 
-Router for grouping routes.
+Router for grouping operations, applying middleware, and mounting controllers. Additionally
+they are effective for creating sub-applications that are independently tested. Routers can 
+have OpenAPI spec applied to all endpoints of the router. Additionally they can be mounted
+onto the main application or other routers.
+
+When a router is mounted to an app, if you are using the DebugView plugin you will be able to
+see it under the Registry tab and the Graph tab.
 
 ```typescript
 const router = new ShokupanRouter(config?: ShokupanRouteConfig);
@@ -1592,6 +1757,13 @@ Request context object.
 - `state: Record<string, any>` - Shared state object
 - `session: any` - Session data (with session plugin)
 - `response: ShokupanResponse` - Response builder
+- `ip: string` - Client IP address
+- `hostname: string` - Hostname (e.g. "localhost")
+- `host: string` - Host (e.g. "localhost:3000")
+- `protocol: string` - Protocol (http/https)
+- `secure: boolean` - Whether the request is secure over HTTPS
+- `origin: string` - Origin URL
+- `signal: AbortSignal` - Request abort signal (for standard fetch requests)
 
 **Methods:**
 - `set(name: string, value: string): ShokupanContext` - Set a response header
@@ -1602,6 +1774,7 @@ Request context object.
 - `json(data: any, status?: number): ShokupanContext` - Return JSON response
 - `text(data: string, status?: number): ShokupanContext` - Return text response
 - `html(data: string, status?: number): ShokupanContext` - Return HTML response
+- `jsx(element: any): ShokupanContext` - Render a JSX element
 - `redirect(url: string, status?: number): ShokupanContext` - Redirect response
 - `file(path: string, fileOptions?: BlobPropertyBag, responseOptions?: ResponseInit): Response` - Return file response
 
@@ -1639,7 +1812,6 @@ Container.clear();
 - 🚧 **Framework Plugins** - Drop-in adapters for [Express](https://expressjs.com/), [Koa](https://koajs.com/), and [Elysia](https://elysiajs.com/)
 - 🚧 **Enhanced WebSockets** - Event support and HTTP simulation
 - 🚧 **Benchmarks** - Comprehensive performance comparisons
-- 🚧 **Scaling** - Automatic clustering support
 - 🚧 **RPC Support** - [tRPC](https://trpc.io/) and [gRPC](https://grpc.io/) integration
 - 🚧 **Binary Formats** - [Protobuf](https://protobuf.dev/) and [MessagePack](https://msgpack.org/) support
 - 🚧 **Reliability** - Circuit breaker pattern for resilience
@@ -1652,7 +1824,7 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 1. Fork the repository
 2. Create your feature branch (`git checkout -b feature/amazing-feature`)
 3. Commit your changes (`git commit -m 'Add some amazing feature'`)
-4. Push to the branch (`git push origin feature/amazing-feature`)
+4. Publish the branch (`git push origin feature/amazing-feature`)
 5. Open a Pull Request
 
 ## 📝 License
@@ -1664,7 +1836,8 @@ MIT License - see the [LICENSE](LICENSE) file for details.
 - Inspired by [Express](https://expressjs.com/), [Koa](https://koajs.com/), [NestJS](https://nestjs.com/), and [Elysia](https://elysiajs.com/)
 - Built for the amazing [Bun](https://bun.sh/) runtime
 - Powered by [Arctic](https://github.com/pilcrowonpaper/arctic) for OAuth2 support
+- Tests and Benchmarks created with Antigravity
 
 ---
 
-**Made with 🍞 by the Shokupan team**
+**Made with ❤️ by the Shokupan team**

package/dist/benchmarking/advanced-cases/elysia.d.ts

@@ -0,0 +1 @@
+export declare function startAdvanced(port: number, scenario: string): Promise<() => Promise<void>>;

package/dist/benchmarking/advanced-cases/express.d.ts

@@ -0,0 +1 @@
+export declare function startAdvanced(port: number, scenario: string): Promise<() => Promise<void>>;

package/dist/benchmarking/advanced-cases/fastify.d.ts

@@ -0,0 +1 @@
+export declare function startAdvanced(port: number, scenario: string): Promise<() => Promise<void>>;

package/dist/benchmarking/advanced-cases/hapi.d.ts

@@ -0,0 +1 @@
+export declare function startAdvanced(port: number, scenario: string): Promise<() => Promise<void>>;

package/dist/benchmarking/advanced-cases/hono.d.ts

@@ -0,0 +1 @@
+export declare function startAdvanced(port: number, scenario: string): Promise<() => Promise<void>>;

package/dist/benchmarking/advanced-cases/koa.d.ts

@@ -0,0 +1 @@
+export declare function startAdvanced(port: number, scenario: string): Promise<() => Promise<void>>;

package/dist/benchmarking/advanced-cases/nest.d.ts

@@ -0,0 +1 @@
+export declare function startAdvanced(port: number, scenario: string): Promise<() => Promise<void>>;

package/dist/benchmarking/advanced-cases/shokupan.d.ts

@@ -0,0 +1 @@
+export declare function startAdvanced(port: number, scenario: string): Promise<() => Promise<void>>;

package/dist/benchmarking/advanced-data.d.ts

@@ -0,0 +1,33 @@
+export declare const LARGE_JSON: {
+    total: number;
+    items: any[];
+    metadata: {
+        generated: string;
+        size: string;
+        purpose: string;
+    };
+};
+export declare const LARGE_REQUEST_BODY: string;
+export declare const LARGE_HEADERS: Record<string, string>;
+/**
+ * Calculate MD5 hash of a string
+ */
+export declare function md5(input: string): string;
+/**
+ * Serialize request data for hashing
+ */
+export declare function serializeRequest(url: string, headers: Record<string, string>, body: string): string;
+/**
+ * Get the actual byte size of the LARGE_JSON
+ */
+export declare function getLargeJSONSize(): number;
+/**
+ * Smaller compressible response (100KB) for compression testing
+ */
+export declare const COMPRESSIBLE_JSON: {
+    data: {
+        id: number;
+        text: string;
+        timestamp: string;
+    }[];
+};

package/dist/benchmarking/advanced-runner.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/benchmarking/cases/elysia.d.ts

@@ -0,0 +1 @@
+export declare function start(port: number): Promise<() => Promise<void>>;

package/dist/benchmarking/cases/express.d.ts

@@ -0,0 +1 @@
+export declare function start(port: number): Promise<() => Promise<void>>;

package/dist/benchmarking/cases/fastify.d.ts

@@ -0,0 +1 @@
+export declare function start(port: number): Promise<() => Promise<void>>;

package/dist/benchmarking/cases/hapi.d.ts

@@ -0,0 +1 @@
+export declare function start(port: number): Promise<() => Promise<void>>;

package/dist/benchmarking/cases/hono.d.ts

@@ -0,0 +1 @@
+export declare function start(port: number): Promise<() => Promise<void>>;

package/dist/benchmarking/cases/koa.d.ts

@@ -0,0 +1 @@
+export declare function start(port: number): Promise<() => Promise<void>>;

package/dist/benchmarking/cases/nest.d.ts

@@ -0,0 +1 @@
+export declare function start(port: number): Promise<() => Promise<void>>;

package/dist/benchmarking/cases/shokupan.d.ts

@@ -0,0 +1 @@
+export declare function start(port: number): Promise<() => Promise<void>>;

package/dist/benchmarking/data.d.ts

@@ -0,0 +1,15 @@
+export declare const MEDIUM_JSON: {
+    id: number;
+    name: string;
+    timestamp: string;
+    tags: string[];
+    nested: {
+        layer1: {
+            layer2: {
+                value: string;
+                numbers: number[];
+            };
+        };
+    };
+    description: string;
+};

package/dist/benchmarking/quick_bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/benchmarking/runner.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/buntest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.cjs

@@ -4,7 +4,7 @@ const p = require("@clack/prompts");
 const fs = require("node:fs");
 const path = require("node:path");
 const promises = require("node:timers/promises");
-const openapiAnalyzer = require("./openapi-analyzer-BN0wFCML.cjs");
+const openapiAnalyzer = require("./openapi-analyzer-D9YB3IkV.cjs");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {

package/dist/cli.js

@@ -3,7 +3,7 @@ import * as p from "@clack/prompts";
 import fs from "node:fs";
 import path from "node:path";
 import { setTimeout } from "node:timers/promises";
-import { analyzeDirectory } from "./openapi-analyzer-BTExMLX4.js";
+import { analyzeDirectory } from "./openapi-analyzer-BtIaHIfe.js";
 const templates = {
   controller: (name) => `import { Controller, Get, Ctx } from 'shokupan';
 import { ShokupanContext } from 'shokupan';

package/dist/context.d.ts

@@ -9,18 +9,30 @@ export interface HandlerStackItem {
     file: string;
     line: number;
     stateChanges?: Record<string, any>;
+    startTime?: number;
+    duration?: number;
+}
+export interface DebugCollector {
+    trackStep(id: string | undefined, type: string, duration: number, status: 'success' | 'error', error?: any): void;
+    trackEdge(fromId: string | undefined, toId: string | undefined): void;
+    setNode(id: string): void;
+    getCurrentNode(): string | undefined;
 }
 export declare class ShokupanContext<State extends Record<string, any> = Record<string, any>> {
     readonly request: ShokupanRequest<any>;
-    readonly server?: Server;
+    readonly server?: Server<any>;
     readonly app?: Shokupan;
+    readonly signal?: AbortSignal;
     private _url;
     params: Record<string, string>;
     state: State;
     handlerStack: HandlerStackItem[];
     readonly response: ShokupanResponse;
+    _debug?: DebugCollector;
     _finalResponse?: Response;
-    constructor(request: ShokupanRequest<any>, server?: Server, state?: State, app?: Shokupan, enableMiddlewareTracking?: boolean);
+    _rawBody?: string | ArrayBuffer | Uint8Array;
+    constructor(request: ShokupanRequest<any>, server?: Server<any>, state?: State, app?: Shokupan, signal?: AbortSignal, // Optional as it might not be provided in tests or simple creates
+    enableMiddlewareTracking?: boolean);
     get url(): URL;
     /**
      * Base request
@@ -37,13 +49,11 @@ export declare class ShokupanContext<State extends Record<string, any> = Record<
     /**
      * Request query params
      */
-    get query(): {
-        [k: string]: string;
-    };
+    get query(): Record<string, any>;
     /**
      * Client IP address
      */
-    get ip(): Bun.SocketAddress;
+    get ip(): any;
     /**
      * Request hostname (e.g. "localhost")
      */
@@ -126,7 +136,7 @@ export declare class ShokupanContext<State extends Record<string, any> = Record<
     /**
      * Respond with a file
      */
-    file(path: string, fileOptions?: BlobPropertyBag, responseOptions?: ResponseInit): Response;
+    file(path: string, fileOptions?: BlobPropertyBag, responseOptions?: ResponseInit): Promise<Response>;
     /**
      * JSX Rendering Function
      */

package/dist/decorators.d.ts

@@ -1,3 +1,4 @@
+import { RateLimitOptions } from './plugins/rate-limit';
 import { GuardAPISpec, MethodAPISpec, Middleware } from './types';
 /**
  * Class Decorator: Defines the base path for a controller.
@@ -7,21 +8,67 @@ export declare function Controller(path?: string): (target: any) => void;
  * Decorator: Applies middleware to a class or method.
  */
 export declare function Use(...middleware: Middleware[]): (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a parameter to the request body.
+ */
 export declare const Body: (name?: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Decorator: Binds a parameter to the request parameters.
+ */
 export declare const Param: (name?: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Decorator: Binds a parameter to the request query string.
+ */
 export declare const Query: (name?: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Decorator: Binds a parameter to the request headers.
+ */
 export declare const Headers: (name?: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Decorator: Binds a parameter to the request object.
+ */
 export declare const Req: (name?: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+/**
+ * Decorator: Binds a parameter to the request context.
+ */
 export declare const Ctx: (name?: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
 /**
  * Decorator: Overrides the OpenAPI specification for a route.
  */
 export declare function Spec(spec: MethodAPISpec | GuardAPISpec): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the GET HTTP verb.
+ */
 export declare const Get: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the POST HTTP verb.
+ */
 export declare const Post: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the PUT HTTP verb.
+ */
 export declare const Put: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the DELETE HTTP verb.
+ */
 export declare const Delete: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the PATCH HTTP verb.
+ */
 export declare const Patch: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the OPTIONS HTTP verb.
+ */
 export declare const Options: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the HEAD HTTP verb.
+ */
 export declare const Head: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to ANY HTTP verb.
+ */
 export declare const All: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Applies a rate limit to a class or method.
+ */
+export declare function RateLimit(options: RateLimitOptions): (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void;