@tongei/express-response-envelop 0.0.1

package/README.md

@@ -0,0 +1,480 @@
+# @tongei/express-response-envelop
+
+A lightweight Express.js library for centralizing and standardizing API responses with a consistent envelope structure.
+
+## Installation
+
+```bash
+npm install @tongei/express-response-envelop
+```
+
+## Response Shape
+
+**Success:**
+```json
+{
+  "success": true,
+  "message": "Users fetched successfully",
+  "data": [...],
+  "optional": {
+    "apiVersion": "1.0.0",
+    "timestamp": "2025-01-01T00:00:00.000Z"
+  }
+}
+```
+
+**Error:**
+```json
+{
+  "success": false,
+  "message": null,
+  "error": {
+    "status": 404,
+    "message": "User not found",
+    "details": { "field": "id" }
+  },
+  "optional": {
+    "apiVersion": "1.0.0",
+    "timestamp": "2025-01-01T00:00:00.000Z"
+  }
+}
+```
+
+---
+
+## Usage
+
+There are two ways to use this library. You can use them together or independently.
+
+---
+
+### Option A — Global Middleware (Opt-out model)
+
+Register the middleware once and **every `res.json()` call** is automatically wrapped in a success envelope.
+
+```ts
+import express from 'express';
+import {
+  responseEnvelopMiddleware,
+  envelopErrorHandler,
+} from '@tongei/express-response-envelop';
+
+const app = express();
+app.use(express.json());
+
+// 1. Register the global response middleware
+app.use(
+  responseEnvelopMiddleware({
+    defaultApiVersion: '1.0.0', // optional
+    includeTimestamp: true,      // default: true
+  }),
+);
+
+// Your routes — no changes needed
+app.get('/users', (req, res) => {
+  res.json([{ id: 1, name: 'Alice' }]);
+  // Response: { success: true, message: null, data: [...], optional: { ... } }
+});
+
+// 2. Register the error handler LAST (after all routes)
+app.use(
+  envelopErrorHandler({
+    defaultApiVersion: '1.0.0',
+  }),
+);
+
+app.listen(3000);
+```
+
+#### Opt-out per route
+
+If a specific route should skip the envelope (e.g., a health-check or file download), set `res.locals.skipEnvelop = true` before calling `res.json()`:
+
+```ts
+app.get('/health', (req, res) => {
+  res.locals.skipEnvelop = true;
+  res.json({ status: 'ok' }); // returned as-is, not wrapped
+});
+```
+
+---
+
+### Option B — Route-level Helpers (Explicit / Opt-in model)
+
+Use the `sendEnvelop` and `sendErrorEnvelop` helpers for fine-grained control on specific routes, without using the global middleware.
+
+```ts
+import express from 'express';
+import {
+  sendEnvelop,
+  sendErrorEnvelop,
+  envelopErrorHandler,
+} from '@tongei/express-response-envelop';
+
+const app = express();
+app.use(express.json());
+
+// Success — static message
+app.get('/users', (req, res) => {
+  const users = [{ id: 1, name: 'Alice' }];
+  sendEnvelop(res, users, { message: 'Users fetched successfully' });
+});
+
+// Success — dynamic message based on the data
+app.get('/users/:id', (req, res) => {
+  const user = { id: 1, name: 'Alice' };
+  sendEnvelop(res, user, {
+    message: (data) => `User ${data.name} retrieved`,
+  });
+});
+
+// Success — with custom status and API version
+app.post('/users', (req, res) => {
+  const newUser = { id: 2, name: 'Bob' };
+  sendEnvelop(res, newUser, {
+    status: 201,
+    message: 'User created',
+    apiVersion: '1.0.0',
+  });
+});
+
+// Error — explicit
+app.get('/users/:id', (req, res) => {
+  sendErrorEnvelop(res, 404, 'User not found');
+});
+
+// Error — with details (e.g. validation)
+app.post('/users', (req, res) => {
+  sendErrorEnvelop(res, 400, 'Validation failed', {
+    details: [{ field: 'email', message: 'Required' }],
+  });
+});
+
+// Register error handler last
+app.use(envelopErrorHandler());
+
+app.listen(3000);
+```
+
+---
+
+### Mixing Both Approaches
+
+You can use the global middleware AND the route-level helpers together. The helpers automatically set `res.locals.skipEnvelop = true` to prevent double-wrapping.
+
+```ts
+app.use(responseEnvelopMiddleware({ defaultApiVersion: '1.0.0' }));
+
+// This route uses the global middleware — res.json is auto-wrapped
+app.get('/products', (req, res) => {
+  res.json([{ id: 1 }]);
+});
+
+// This route uses explicit helpers — no double-wrap
+app.post('/products', (req, res) => {
+  sendEnvelop(res, { id: 2 }, { status: 201, message: 'Created' });
+});
+
+app.use(envelopErrorHandler({ defaultApiVersion: '1.0.0' }));
+```
+
+---
+
+## API Reference
+
+### `responseEnvelopMiddleware(options?)`
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `defaultApiVersion` | `string` | `undefined` | Included in `optional.apiVersion` of every response |
+| `includeTimestamp` | `boolean` | `true` | Whether to include `optional.timestamp` |
+
+### `envelopErrorHandler(options?)`
+
+Same options as `responseEnvelopMiddleware`. Must be the **last** middleware registered.
+
+Automatically detects `err.status`, `err.statusCode`, `err.errors`, and `err.details`.
+
+### `sendEnvelop(res, data, options?)`
+
+| Option | Type | Description |
+|---|---|---|
+| `message` | `string \| (data) => string` | Static or dynamic message |
+| `status` | `number` | HTTP status code (default: `200`) |
+| `apiVersion` | `string` | Overrides the `optional.apiVersion` |
+| `includeTimestamp` | `boolean` | Whether to include timestamp |
+
+### `sendErrorEnvelop(res, status, message, options?)`
+
+| Option | Type | Description |
+|---|---|---|
+| `details` | `unknown` | Additional error details (e.g. validation errors) |
+| `apiVersion` | `string` | Overrides the `optional.apiVersion` |
+| `includeTimestamp` | `boolean` | Whether to include timestamp |
+
+### Builder utilities (low-level)
+
+```ts
+import {
+  buildSuccessEnvelope,
+  buildErrorEnvelope,
+} from '@tongei/express-response-envelop';
+
+const success = buildSuccessEnvelope(data, { message: 'Done', apiVersion: '1.0' });
+const error   = buildErrorEnvelope(500, 'Internal error', { details: { ... } });
+```
+
+---
+
+## NestJS-style Exceptions
+
+The package ships typed HTTP exception classes — exactly like NestJS — so you can `throw` them directly from any route handler, service, or middleware. The `envelopErrorHandler` catches them automatically.
+
+### Available exceptions
+
+```ts
+import {
+  // 4xx
+  BadRequestException,         // 400
+  UnauthorizedException,       // 401
+  PaymentRequiredException,    // 402
+  ForbiddenException,          // 403
+  NotFoundException,           // 404
+  MethodNotAllowedException,   // 405
+  NotAcceptableException,      // 406
+  RequestTimeoutException,     // 408
+  ConflictException,           // 409
+  GoneException,               // 410
+  PayloadTooLargeException,    // 413
+  UnsupportedMediaTypeException, // 415
+  UnprocessableEntityException,// 422
+  TooManyRequestsException,    // 429
+  // 5xx
+  InternalServerErrorException,// 500
+  NotImplementedException,     // 501
+  BadGatewayException,         // 502
+  ServiceUnavailableException, // 503
+  GatewayTimeoutException,     // 504
+} from '@tongei/express-response-envelop';
+```
+
+### Throwing exceptions
+
+```ts
+import express from 'express';
+import {
+  responseEnvelopMiddleware,
+  envelopErrorHandler,
+  NotFoundException,
+  ConflictException,
+  ForbiddenException,
+  UnprocessableEntityException,
+} from '@tongei/express-response-envelop';
+
+const app = express();
+app.use(express.json());
+app.use(responseEnvelopMiddleware({ defaultApiVersion: '1.0.0' }));
+
+app.get('/users/:id', (req, res) => {
+  const user = db.findUser(req.params.id);
+
+  if (!user) {
+    throw new NotFoundException(`User ${req.params.id} not found`);
+    // { success: false, error: { status: 404, message: 'User 42 not found' } }
+  }
+
+  res.json(user);
+});
+
+app.post('/users', (req, res) => {
+  if (db.emailExists(req.body.email)) {
+    throw new ConflictException('Email is already in use');
+    // { success: false, error: { status: 409, message: 'Email is already in use' } }
+  }
+
+  if (!req.user?.isAdmin) {
+    throw new ForbiddenException('Admin access required');
+    // { success: false, error: { status: 403, message: 'Admin access required' } }
+  }
+
+  res.json(db.createUser(req.body));
+});
+
+// Register the error handler LAST — it catches all thrown exceptions
+app.use(envelopErrorHandler({ defaultApiVersion: '1.0.0' }));
+app.listen(3000);
+```
+
+> [!NOTE]
+> The exceptions work with both `throw` and `next(err)`. You can throw them synchronously or pass them to `next()` in async routes.
+
+### Throwing with validation details
+
+Pass a second argument to attach structured detail to the error response:
+
+```ts
+app.post('/register', (req, res) => {
+  const errors = validate(req.body);
+
+  if (errors.length > 0) {
+    throw new UnprocessableEntityException('Validation failed', errors);
+    // {
+    //   "success": false,
+    //   "error": {
+    //     "status": 422,
+    //     "message": "Validation failed",
+    //     "details": [{ "field": "email", "message": "Required" }]
+    //   }
+    // }
+  }
+
+  res.json(db.register(req.body));
+});
+```
+
+### Custom domain exceptions
+
+Extend `HttpException` for domain-specific errors:
+
+```ts
+import { HttpException } from '@tongei/express-response-envelop';
+
+export class EntityNotFoundException extends HttpException {
+  constructor(entity: string, id: string | number) {
+    super(404, `${entity} with id "${id}" was not found`);
+  }
+}
+
+export class SubscriptionExpiredException extends HttpException {
+  constructor() {
+    super(402, 'Your subscription has expired');
+  }
+}
+
+// Usage:
+throw new EntityNotFoundException('Product', req.params.id);
+throw new SubscriptionExpiredException();
+```
+
+---
+
+## Custom Exception Filters
+
+Register class-specific handlers in `envelopErrorHandler` — just like NestJS's `@Catch()` decorator. Filters are evaluated in order; the first match wins. Unmatched errors fall through to the default handler.
+
+```ts
+import {
+  envelopErrorHandler,
+  sendErrorEnvelop,
+  EnvelopExceptionFilter,
+} from '@tongei/express-response-envelop';
+
+// 1. Define your domain exception
+class DatabaseException extends Error {
+  constructor(message = 'Database error') {
+    super(message);
+    this.name = 'DatabaseException';
+  }
+}
+
+class RateLimitException extends Error {
+  retryAfter: number;
+  constructor(retryAfter = 60) {
+    super('Too many requests');
+    this.retryAfter = retryAfter;
+  }
+}
+
+// 2. Create filters
+const dbFilter: EnvelopExceptionFilter<DatabaseException> = {
+  exceptionType: DatabaseException,
+  handle(err, req, res) {
+    sendErrorEnvelop(res, 503, 'Database unavailable', {
+      details: { reason: err.message },
+    });
+  },
+};
+
+const rateLimitFilter: EnvelopExceptionFilter<RateLimitException> = {
+  exceptionType: RateLimitException,
+  handle(err, req, res) {
+    res.setHeader('Retry-After', err.retryAfter);
+    sendErrorEnvelop(res, 429, 'Too many requests', {
+      details: { retryAfter: err.retryAfter },
+    });
+  },
+};
+
+// 3. Register filters — first match wins
+app.use(
+  envelopErrorHandler({
+    defaultApiVersion: '1.0.0',
+    filters: [dbFilter, rateLimitFilter],
+  }),
+);
+```
+
+---
+
+## Throwing Errors (plain Express style)
+
+If you prefer not to use the typed exceptions, you can still use the classic Express pattern of attaching `status` to a plain error and passing it to `next()`:
+
+```ts
+app.get('/users/:id', (req, res, next) => {
+  const user = db.findUser(req.params.id);
+
+  if (!user) {
+    const err: any = new Error('User not found');
+    err.status = 404;
+    return next(err);
+  }
+
+  res.json(user);
+});
+```
+
+Works seamlessly with [`http-errors`](https://github.com/jshttp/http-errors):
+
+```bash
+npm install http-errors && npm install -D @types/http-errors
+```
+
+```ts
+import createError from 'http-errors';
+
+app.get('/protected', (req, res, next) => {
+  if (!req.headers.authorization) {
+    return next(createError(401, 'Authorization header missing'));
+  }
+  res.json({ secret: 'data' });
+});
+```
+
+### Global 500 fallback
+
+Any error without a `status` property (including uncaught `throw new Error(...)`) defaults to `500 Internal Server Error`:
+
+```ts
+app.get('/risky', async (req, res, next) => {
+  try {
+    const data = await someFlakyOperation();
+    res.json(data);
+  } catch (err) {
+    next(err);
+    // { success: false, error: { status: 500, message: '...' } }
+  }
+});
+
+// Or with the typed exception:
+app.get('/risky2', (req, res) => {
+  throw new InternalServerErrorException('Something went wrong internally');
+});
+```
+
+---
+
+## License
+
+MIT
+

package/dist/builder/envelope.builder.d.ts

@@ -0,0 +1,30 @@
+export interface EnvelopeOptionalMeta {
+    apiVersion?: string;
+    timestamp?: string;
+}
+export interface SuccessEnvelope<T> {
+    success: true;
+    message: string | null;
+    data: T;
+    optional?: EnvelopeOptionalMeta;
+}
+export interface ErrorEnvelope {
+    success: false;
+    message: string | null;
+    error?: {
+        status: number;
+        message: string;
+        details?: unknown;
+    };
+    optional?: EnvelopeOptionalMeta;
+}
+export declare function buildSuccessEnvelope<T>(data: T, opts?: {
+    message?: string | null;
+    apiVersion?: string;
+    includeTimestamp?: boolean;
+}): SuccessEnvelope<T>;
+export declare function buildErrorEnvelope(status: number, message: string, opts?: {
+    apiVersion?: string;
+    includeTimestamp?: boolean;
+    details?: unknown;
+}): ErrorEnvelope;

package/dist/builder/envelope.builder.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSuccessEnvelope = buildSuccessEnvelope;
+exports.buildErrorEnvelope = buildErrorEnvelope;
+function buildOptional(apiVersion, includeTimestamp = true) {
+    const optional = {};
+    if (apiVersion !== undefined)
+        optional.apiVersion = apiVersion;
+    if (includeTimestamp)
+        optional.timestamp = new Date().toISOString();
+    return Object.keys(optional).length > 0 ? optional : undefined;
+}
+function buildSuccessEnvelope(data, opts = {}) {
+    return {
+        success: true,
+        message: opts.message ?? null,
+        data,
+        optional: buildOptional(opts.apiVersion, opts.includeTimestamp ?? true),
+    };
+}
+function buildErrorEnvelope(status, message, opts = {}) {
+    return {
+        success: false,
+        message: null,
+        error: {
+            status,
+            message,
+            ...(opts.details ? { details: opts.details } : {}),
+        },
+        optional: buildOptional(opts.apiVersion, opts.includeTimestamp ?? true),
+    };
+}
+//# sourceMappingURL=envelope.builder.js.map

package/dist/builder/envelope.builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.builder.js","sourceRoot":"","sources":["../../src/builder/envelope.builder.ts"],"names":[],"mappings":";;AA8BA,oDAcC;AAED,gDAmBC;AA7CD,SAAS,aAAa,CACpB,UAAmB,EACnB,gBAAgB,GAAG,IAAI;IAEvB,MAAM,QAAQ,GAAyB,EAAE,CAAC;IAC1C,IAAI,UAAU,KAAK,SAAS;QAAE,QAAQ,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/D,IAAI,gBAAgB;QAAE,QAAQ,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACpE,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;AACjE,CAAC;AAED,SAAgB,oBAAoB,CAClC,IAAO,EACP,OAII,EAAE;IAEN,OAAO;QACL,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,IAAI,CAAC,OAAO,IAAI,IAAI;QAC7B,IAAI;QACJ,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC;KACxE,CAAC;AACJ,CAAC;AAED,SAAgB,kBAAkB,CAChC,MAAc,EACd,OAAe,EACf,OAII,EAAE;IAEN,OAAO;QACL,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,IAAI;QACb,KAAK,EAAE;YACL,MAAM;YACN,OAAO;YACP,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACnD;QACD,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC;KACxE,CAAC;AACJ,CAAC"}

package/dist/error-handler/envelop-error-handler.d.ts

@@ -0,0 +1,7 @@
+import { ErrorRequestHandler } from 'express';
+import { EnvelopExceptionFilter } from '../filters/exception-filter.type';
+import { EnvelopMiddlewareOptions } from '../types/response-envelop-option.type';
+export interface EnvelopErrorHandlerOptions extends EnvelopMiddlewareOptions {
+    filters?: EnvelopExceptionFilter[];
+}
+export declare function envelopErrorHandler(options?: EnvelopErrorHandlerOptions): ErrorRequestHandler;

package/dist/error-handler/envelop-error-handler.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envelopErrorHandler = envelopErrorHandler;
+const envelope_builder_1 = require("../builder/envelope.builder");
+const http_exception_1 = require("../exceptions/http.exception");
+function envelopErrorHandler(options = {}) {
+    const { defaultApiVersion, includeTimestamp, filters = [] } = options;
+    return function errorHandler(err, req, res, next) {
+        for (const filter of filters) {
+            if (err instanceof filter.exceptionType) {
+                filter.handle(err, req, res, next);
+                return;
+            }
+        }
+        if (err instanceof http_exception_1.HttpException) {
+            const envelope = (0, envelope_builder_1.buildErrorEnvelope)(err.status, err.message, {
+                apiVersion: defaultApiVersion,
+                includeTimestamp,
+                details: err.details,
+            });
+            res.status(err.status).json(envelope);
+            return;
+        }
+        const status = typeof err?.status === 'number'
+            ? err.status
+            : typeof err?.statusCode === 'number'
+                ? err.statusCode
+                : 500;
+        const message = typeof err?.message === 'string' && err.message
+            ? err.message
+            : 'Internal Server Error';
+        const details = err?.errors ?? err?.details ?? (err instanceof Error ? undefined : err);
+        const envelope = (0, envelope_builder_1.buildErrorEnvelope)(status, message, {
+            apiVersion: defaultApiVersion,
+            includeTimestamp,
+            details,
+        });
+        res.status(status).json(envelope);
+    };
+}
+//# sourceMappingURL=envelop-error-handler.js.map

package/dist/error-handler/envelop-error-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelop-error-handler.js","sourceRoot":"","sources":["../../src/error-handler/envelop-error-handler.ts"],"names":[],"mappings":";;AAyDA,kDAwDC;AA/GD,kEAAiE;AACjE,iEAA6D;AAsD7D,SAAgB,mBAAmB,CACjC,UAAsC,EAAE;IAExC,MAAM,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,OAAO,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC;IAGtE,OAAO,SAAS,YAAY,CAC1B,GAAQ,EACR,GAAY,EACZ,GAAa,EACb,IAAkB;QAGlB,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,GAAG,YAAY,MAAM,CAAC,aAAa,EAAE,CAAC;gBACxC,MAAM,CAAC,MAAM,CAAC,GAAU,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;gBAC1C,OAAO;YACT,CAAC;QACH,CAAC;QAGD,IAAI,GAAG,YAAY,8BAAa,EAAE,CAAC;YACjC,MAAM,QAAQ,GAAG,IAAA,qCAAkB,EAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,EAAE;gBAC3D,UAAU,EAAE,iBAAiB;gBAC7B,gBAAgB;gBAChB,OAAO,EAAE,GAAG,CAAC,OAAO;aACrB,CAAC,CAAC;YACH,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACtC,OAAO;QACT,CAAC;QAGD,MAAM,MAAM,GACV,OAAO,GAAG,EAAE,MAAM,KAAK,QAAQ;YAC7B,CAAC,CAAC,GAAG,CAAC,MAAM;YACZ,CAAC,CAAC,OAAO,GAAG,EAAE,UAAU,KAAK,QAAQ;gBACnC,CAAC,CAAC,GAAG,CAAC,UAAU;gBAChB,CAAC,CAAC,GAAG,CAAC;QAEZ,MAAM,OAAO,GACX,OAAO,GAAG,EAAE,OAAO,KAAK,QAAQ,IAAI,GAAG,CAAC,OAAO;YAC7C,CAAC,CAAC,GAAG,CAAC,OAAO;YACb,CAAC,CAAC,uBAAuB,CAAC;QAE9B,MAAM,OAAO,GACX,GAAG,EAAE,MAAM,IAAI,GAAG,EAAE,OAAO,IAAI,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAG1E,MAAM,QAAQ,GAAG,IAAA,qCAAkB,EAAC,MAAM,EAAE,OAAO,EAAE;YACnD,UAAU,EAAE,iBAAiB;YAC7B,gBAAgB;YAChB,OAAO;SACR,CAAC,CAAC;QAEH,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACpC,CAAC,CAAC;AACJ,CAAC"}

package/dist/exceptions/built-in.exceptions.d.ts

@@ -0,0 +1,58 @@
+import { HttpException } from './http.exception';
+export declare class BadRequestException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class UnauthorizedException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class PaymentRequiredException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class ForbiddenException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class NotFoundException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class MethodNotAllowedException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class NotAcceptableException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class RequestTimeoutException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class ConflictException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class GoneException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class PayloadTooLargeException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class UnsupportedMediaTypeException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class UnprocessableEntityException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class TooManyRequestsException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class InternalServerErrorException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class NotImplementedException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class BadGatewayException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class ServiceUnavailableException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}
+export declare class GatewayTimeoutException extends HttpException {
+    constructor(message?: string, details?: unknown);
+}