http-proxy-middleware 4.0.0-beta.0 → 4.0.0-beta.3

package/README.md

@@ -5,20 +5,19 @@
 [![Known Vulnerabilities](https://snyk.io/test/github/chimurai/http-proxy-middleware/badge.svg)](https://snyk.io/test/github/chimurai/http-proxy-middleware)
 [![npm](https://img.shields.io/npm/v/http-proxy-middleware?color=%23CC3534&style=flat-square&logo=npm)](https://www.npmjs.com/package/http-proxy-middleware)
 
-Node.js proxying made simple. Configure proxy middleware with ease for [connect](https://github.com/senchalabs/connect), [express](https://github.com/expressjs/express), [next.js](https://github.com/vercel/next.js) and [many more](#compatible-servers).
+Node.js proxying made simple. Configure proxy middleware with ease for [connect](https://github.com/senchalabs/connect), [express](https://github.com/expressjs/express), [next.js](https://github.com/vercel/next.js), [hono](https://github.com/honojs/hono) and [many more](#compatible-servers).
 
-Powered by the popular Nodejitsu [`http-proxy`](https://github.com/http-party/node-http-proxy). [![GitHub stars](https://img.shields.io/github/stars/http-party/node-http-proxy.svg?style=social&label=Star)](https://github.com/http-party/node-http-proxy)
+Powered by [`httpxy`](https://github.com/unjs/httpxy). A maintained version of [http-proxy](https://github.com/http-party/node-http-proxy).
 
 ## ⚠️ Note <!-- omit in toc -->
 
-This page is showing documentation for version v3.x.x ([release notes](https://github.com/chimurai/http-proxy-middleware/releases))
+This page is showing documentation for version **v4.x.x** ([release notes](https://github.com/chimurai/http-proxy-middleware/releases))
 
-See [MIGRATION.md](https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md) for details on how to migrate from v2.x.x to v3.x.x
+For older documentation:
 
-If you're looking for older documentation. Go to:
-
-- <https://github.com/chimurai/http-proxy-middleware/tree/v2.0.4#readme>
-- <https://github.com/chimurai/http-proxy-middleware/tree/v0.21.0#readme>
+- [v3.0.5](https://github.com/chimurai/http-proxy-middleware/tree/v3.0.5#readme)
+- [v2.0.4](https://github.com/chimurai/http-proxy-middleware/tree/v2.0.4#readme)
+- [v0.21.0](https://github.com/chimurai/http-proxy-middleware/tree/v0.21.0#readme)
 
 ## TL;DR <!-- omit in toc -->
 
@@ -28,7 +27,7 @@ Proxy `/api` requests to `http://www.example.org`
 
 ```typescript
 // typescript
-import * as express from 'express';
+import express from 'express';
 import type { NextFunction, Request, Response } from 'express';
 import { createProxyMiddleware } from 'http-proxy-middleware';
 import type { Filter, Options, RequestHandler } from 'http-proxy-middleware';
@@ -48,7 +47,7 @@ app.listen(3000);
 // http://127.0.0.1:3000/api/foo/bar -> http://www.example.org/api/foo/bar
 ```
 
-_All_ `http-proxy` [options](https://github.com/nodejitsu/node-http-proxy#options) can be used, along with some extra `http-proxy-middleware` [options](#options).
+_All_ `httpxy` [options](https://github.com/unjs/httpxy#options) can be used, along with some extra `http-proxy-middleware` [options](#options).
 
 ## Table of Contents <!-- omit in toc -->
 
@@ -65,8 +64,8 @@ _All_ `http-proxy` [options](https://github.com/nodejitsu/node-http-proxy#option
   - [`plugins` (Array)](#plugins-array)
   - [`ejectPlugins` (boolean) default: `false`](#ejectplugins-boolean-default-false)
   - [`logger` (Object)](#logger-object)
-- [`http-proxy` events](#http-proxy-events)
-- [`http-proxy` options](#http-proxy-options)
+- [`httpxy` events](#httpxy-events)
+- [`httpxy` options](#httpxy-options)
 - [WebSocket](#websocket)
   - [External WebSocket upgrade](#external-websocket-upgrade)
 - [Intercept and manipulate requests](#intercept-and-manipulate-requests)
@@ -93,7 +92,7 @@ npm install --save-dev http-proxy-middleware
 Create and configure a proxy middleware with: `createProxyMiddleware(config)`.
 
 ```javascript
-const { createProxyMiddleware } = require('http-proxy-middleware');
+import { createProxyMiddleware } from 'http-proxy-middleware';
 
 const apiProxy = createProxyMiddleware({
   target: 'http://www.example.org',
@@ -114,13 +113,13 @@ An example with `express` server.
 
 ```javascript
 // include dependencies
-const express = require('express');
-const { createProxyMiddleware } = require('http-proxy-middleware');
+import express from 'express';
+import { createProxyMiddleware } from 'http-proxy-middleware';
 
 const app = express();
 
 // create the proxy
-/** @type {import('http-proxy-middleware/dist/types').RequestHandler<express.Request, express.Response>} */
+/** @type {import('http-proxy-middleware').RequestHandler<import('express').Request, import('express').Response>} */
 const exampleProxy = createProxyMiddleware({
   target: 'http://www.example.org/api', // target host with the same base path
   changeOrigin: true, // needed for virtual hosted sites
@@ -281,13 +280,15 @@ NOTE: register your own error handlers to prevent server from crashing.
 
 ```js
 // eject default plugins and manually add them back
-
-const {
-  debugProxyErrorsPlugin, // subscribe to proxy errors to prevent server from crashing
-  loggerPlugin, // log proxy events to a logger (ie. console)
-  errorResponsePlugin, // return 5xx response on proxy error
+import {
+  debugProxyErrorsPlugin,
+  // log proxy events to a logger (ie. console)
+  errorResponsePlugin,
+  // subscribe to proxy errors to prevent server from crashing
+  loggerPlugin,
+  // return 5xx response on proxy error
   proxyEventsPlugin, // implements the "on:" option
-} = require('http-proxy-middleware');
+} from 'http-proxy-middleware';
 
 createProxyMiddleware({
   target: `http://example.org`,
@@ -313,9 +314,9 @@ createProxyMiddleware({
 });
 ```
 
-## `http-proxy` events
+## `httpxy` events
 
-Subscribe to [http-proxy events](https://github.com/nodejitsu/node-http-proxy#listening-for-proxy-events) with the `on` option:
+Subscribe to [httpxy events](https://github.com/unjs/httpxy#events) with the `on` option:
 
 ```js
 createProxyMiddleware({
@@ -354,7 +355,7 @@ createProxyMiddleware({
   }
   ```
 
-- **option.on.proxyReq**: function, subscribe to http-proxy's `proxyReq` event.
+- **option.on.proxyReq**: function, subscribe to httpxy's `proxyReq` event.
 
   ```javascript
   function onProxyReq(proxyReq, req, res) {
@@ -364,7 +365,7 @@ createProxyMiddleware({
   }
   ```
 
-- **option.on.proxyReqWs**: function, subscribe to http-proxy's `proxyReqWs` event.
+- **option.on.proxyReqWs**: function, subscribe to httpxy's `proxyReqWs` event.
 
   ```javascript
   function onProxyReqWs(proxyReq, req, socket, options, head) {
@@ -373,7 +374,7 @@ createProxyMiddleware({
   }
   ```
 
-- **option.on.open**: function, subscribe to http-proxy's `open` event.
+- **option.on.open**: function, subscribe to httpxy's `open` event.
 
   ```javascript
   function onOpen(proxySocket) {
@@ -382,7 +383,7 @@ createProxyMiddleware({
   }
   ```
 
-- **option.on.close**: function, subscribe to http-proxy's `close` event.
+- **option.on.close**: function, subscribe to httpxy's `close` event.
 
   ```javascript
   function onClose(res, socket, head) {
@@ -391,9 +392,9 @@ createProxyMiddleware({
   }
   ```
 
-## `http-proxy` options
+## `httpxy` options
 
-The following options are provided by the underlying [http-proxy](https://github.com/nodejitsu/node-http-proxy#options) library.
+The following options are provided by the underlying [httpxy](https://github.com/unjs/httpxy#options) library.
 
 - **option.target**: url string to be parsed with the url module
 - **option.forward**: url string to be parsed with the url module
@@ -448,13 +449,12 @@ The following options are provided by the underlying [http-proxy](https://github
 - **option.buffer**: stream of data to send as the request body. Maybe you have some middleware that consumes the request stream before proxying it on e.g. If you read the body of a request into a field called 'req.rawbody' you could restream this field in the buffer option:
 
   ```javascript
-  'use strict';
+  import { createProxyServer } from 'httpxy';
+  import streamify from 'stream-array';
 
-  const streamify = require('stream-array');
-  const HttpProxy = require('http-proxy');
-  const proxy = new HttpProxy();
+  const proxy = createProxyServer();
 
-  module.exports = (req, res, next) => {
+  export default function proxyWithBody(req, res, next) {
     proxy.web(
       req,
       res,
@@ -464,7 +464,7 @@ The following options are provided by the underlying [http-proxy](https://github
       },
       next,
     );
-  };
+  }
   ```
 
 ## WebSocket
@@ -497,7 +497,7 @@ Currently the only pre-provided request interceptor is `fixRequestBody`, which i
 Example:
 
 ```javascript
-const { createProxyMiddleware, fixRequestBody } = require('http-proxy-middleware');
+import { createProxyMiddleware, fixRequestBody } from 'http-proxy-middleware';
 
 const proxy = createProxyMiddleware({
   /**
@@ -522,7 +522,7 @@ NOTE: `responseInterceptor` disables streaming of target's response.
 Example:
 
 ```javascript
-const { createProxyMiddleware, responseInterceptor } = require('http-proxy-middleware');
+import { createProxyMiddleware, responseInterceptor } from 'http-proxy-middleware';
 
 const proxy = createProxyMiddleware({
   /**
@@ -592,6 +592,7 @@ View the [recipes](https://github.com/chimurai/http-proxy-middleware/tree/master
 
 - [connect](https://www.npmjs.com/package/connect)
 - [express](https://www.npmjs.com/package/express)
+- [hono](https://www.npmjs.com/package/@hono/node-server)
 - [next.js](https://www.npmjs.com/package/next)
 - [fastify](https://www.npmjs.com/package/fastify)
 - [browser-sync](https://www.npmjs.com/package/browser-sync)
@@ -623,7 +624,7 @@ $ yarn build
 $ yarn test
 
 # code coverage
-$ yarn cover
+$ yarn coverage
 
 # check spelling mistakes
 $ yarn spellcheck
@@ -637,4 +638,4 @@ $ yarn spellcheck
 
 The MIT License (MIT)
 
-Copyright (c) 2015-2025 Steven Chim
+Copyright (c) 2015-2026 Steven Chim

package/dist/configuration.d.ts

@@ -1,2 +1,3 @@
-import { Options } from './types';
-export declare function verifyConfig<TReq, TRes>(options: Options<TReq, TRes>): void;
+import type * as http from 'node:http';
+import { Options } from './types.js';
+export declare function verifyConfig<TReq extends http.IncomingMessage, TRes extends http.ServerResponse>(options: Options<TReq, TRes>): void;

package/dist/configuration.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyConfig = verifyConfig;
-const errors_1 = require("./errors");
-function verifyConfig(options) {
+import { ERRORS } from './errors.js';
+export function verifyConfig(options) {
     if (!options.target && !options.router) {
-        throw new Error(errors_1.ERRORS.ERR_CONFIG_FACTORY_TARGET_MISSING);
+        throw new Error(ERRORS.ERR_CONFIG_FACTORY_TARGET_MISSING);
     }
 }

package/dist/debug.d.ts

@@ -1,4 +1,4 @@
-import * as createDebug from 'debug';
+import createDebug from 'debug';
 /**
  * Debug instance with the given namespace: http-proxy-middleware
  */

package/dist/debug.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Debug = void 0;
-const createDebug = require("debug");
+import createDebug from 'debug';
 /**
  * Debug instance with the given namespace: http-proxy-middleware
  */
-exports.Debug = createDebug('http-proxy-middleware');
+export const Debug = createDebug('http-proxy-middleware');

package/dist/errors.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ERRORS = void 0;
-var ERRORS;
+export var ERRORS;
 (function (ERRORS) {
     ERRORS["ERR_CONFIG_FACTORY_TARGET_MISSING"] = "[HPM] Missing \"target\" option. Example: {target: \"http://www.example.org\"}";
     ERRORS["ERR_CONTEXT_MATCHER_GENERIC"] = "[HPM] Invalid pathFilter. Expecting something like: \"/api\" or [\"/api\", \"/ajax\"]";
     ERRORS["ERR_CONTEXT_MATCHER_INVALID_ARRAY"] = "[HPM] Invalid pathFilter. Plain paths (e.g. \"/api\") can not be mixed with globs (e.g. \"/api/**\"). Expecting something like: [\"/api\", \"/ajax\"] or [\"/api/**\", \"!**.html\"].";
     ERRORS["ERR_PATH_REWRITER_CONFIG"] = "[HPM] Invalid pathRewrite config. Expecting object with pathRewrite config or a rewrite function";
-})(ERRORS || (exports.ERRORS = ERRORS = {}));
+})(ERRORS || (ERRORS = {}));

package/dist/factory-hono.d.ts

@@ -0,0 +1,25 @@
+import type { HttpBindings } from '@hono/node-server';
+import type { MiddlewareHandler } from 'hono';
+import { type Options } from './index.js';
+/**
+ * Creates a Hono middleware that proxies requests using http-proxy-middleware.
+ *
+ * `@remarks`
+ * This middleware requires Hono to be running on Node.js via `@hono/node-server`.
+ * It uses `c.env.incoming` and `c.env.outgoing` which are only available with `HttpBindings`.
+ *
+ * `@experimental` This API is experimental and may change without a major version bump.
+ *
+ * `@example`
+ * ```ts
+ * import { serve } from '@hono/node-server';
+ * import { Hono } from 'hono';
+ * import { createHonoProxyMiddleware } from 'http-proxy-middleware';
+ *
+ * const app = new Hono();
+ * app.use('/api', createHonoProxyMiddleware({ target: 'http://example.com', changeOrigin: true }));
+ * serve(app);
+ */
+export declare function createHonoProxyMiddleware(options: Options): MiddlewareHandler<{
+    Bindings: HttpBindings;
+}>;

package/dist/factory-hono.js

@@ -0,0 +1,42 @@
+import { createProxyMiddleware } from './index.js';
+import { getLogger } from './logger.js';
+/**
+ * Creates a Hono middleware that proxies requests using http-proxy-middleware.
+ *
+ * `@remarks`
+ * This middleware requires Hono to be running on Node.js via `@hono/node-server`.
+ * It uses `c.env.incoming` and `c.env.outgoing` which are only available with `HttpBindings`.
+ *
+ * `@experimental` This API is experimental and may change without a major version bump.
+ *
+ * `@example`
+ * ```ts
+ * import { serve } from '@hono/node-server';
+ * import { Hono } from 'hono';
+ * import { createHonoProxyMiddleware } from 'http-proxy-middleware';
+ *
+ * const app = new Hono();
+ * app.use('/api', createHonoProxyMiddleware({ target: 'http://example.com', changeOrigin: true }));
+ * serve(app);
+ */
+export function createHonoProxyMiddleware(options) {
+    const proxy = createProxyMiddleware(options);
+    const logger = getLogger(options);
+    return (c, next) => {
+        return new Promise((resolve, reject) => {
+            proxy(c.env.incoming, c.env.outgoing, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        })
+            .then(() => next())
+            .catch((err) => {
+            logger.error('Proxy error:', err);
+            return c.text('Proxy Error', 500);
+        });
+    };
+}

package/dist/factory.d.ts

@@ -1,3 +1,3 @@
 import type * as http from 'node:http';
-import type { NextFunction, Options, RequestHandler } from './types';
-export declare function createProxyMiddleware<TReq = http.IncomingMessage, TRes = http.ServerResponse, TNext = NextFunction>(options: Options<TReq, TRes>): RequestHandler<TReq, TRes, TNext>;
+import type { NextFunction, Options, RequestHandler } from './types.js';
+export declare function createProxyMiddleware<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse, TNext = NextFunction>(options: Options<TReq, TRes>): RequestHandler<TReq, TRes, TNext>;

package/dist/factory.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createProxyMiddleware = createProxyMiddleware;
-const http_proxy_middleware_1 = require("./http-proxy-middleware");
-function createProxyMiddleware(options) {
-    const { middleware } = new http_proxy_middleware_1.HttpProxyMiddleware(options);
+import { HttpProxyMiddleware } from './http-proxy-middleware.js';
+export function createProxyMiddleware(options) {
+    const { middleware } = new HttpProxyMiddleware(options);
     return middleware;
 }

package/dist/get-plugins.d.ts

@@ -1,2 +1,3 @@
-import type { Options, Plugin } from './types';
-export declare function getPlugins<TReq, TRes>(options: Options<TReq, TRes>): Plugin<TReq, TRes>[];
+import type * as http from 'node:http';
+import type { Options, Plugin } from './types.js';
+export declare function getPlugins<TReq extends http.IncomingMessage, TRes extends http.ServerResponse>(options: Options<TReq, TRes>): Plugin<TReq, TRes>[];

package/dist/get-plugins.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPlugins = getPlugins;
-const default_1 = require("./plugins/default");
-function getPlugins(options) {
+import { debugProxyErrorsPlugin, errorResponsePlugin, loggerPlugin, proxyEventsPlugin, } from './plugins/default/index.js';
+export function getPlugins(options) {
     // don't load default errorResponsePlugin if user has specified their own
-    const maybeErrorResponsePlugin = options.on?.error ? [] : [default_1.errorResponsePlugin];
+    const maybeErrorResponsePlugin = options.on?.error ? [] : [errorResponsePlugin];
     const defaultPlugins = options.ejectPlugins
         ? [] // no default plugins when ejecting
-        : [default_1.debugProxyErrorsPlugin, default_1.proxyEventsPlugin, default_1.loggerPlugin, ...maybeErrorResponsePlugin];
+        : [debugProxyErrorsPlugin, proxyEventsPlugin, loggerPlugin, ...maybeErrorResponsePlugin];
     const userPlugins = options.plugins ?? [];
     return [...defaultPlugins, ...userPlugins];
 }

package/dist/handlers/fix-request-body.js

@@ -1,11 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fixRequestBody = fixRequestBody;
-const querystring = require("node:querystring");
+import * as querystring from 'node:querystring';
+import * as zlib from 'node:zlib';
 /**
  * Fix proxied body if bodyParser is involved.
  */
-function fixRequestBody(proxyReq, req) {
+export function fixRequestBody(proxyReq, req) {
     // skip fixRequestBody() when req.readableLength not 0 (bodyParser failure)
     if (req.readableLength !== 0) {
         return;
@@ -19,8 +17,21 @@ function fixRequestBody(proxyReq, req) {
         return;
     }
     const writeBody = (bodyData) => {
-        proxyReq.setHeader('Content-Length', Buffer.byteLength(bodyData));
-        proxyReq.write(bodyData);
+        let proxyData = bodyData;
+        const contentEncoding = String(proxyReq.getHeader('Content-Encoding')).toLowerCase();
+        switch (contentEncoding) {
+            case 'br':
+                proxyData = zlib.brotliCompressSync(proxyData);
+                break;
+            case 'deflate':
+                proxyData = zlib.deflateSync(proxyData);
+                break;
+            case 'gzip':
+                proxyData = zlib.gzipSync(proxyData);
+                break;
+        }
+        proxyReq.setHeader('Content-Length', Buffer.byteLength(proxyData));
+        proxyReq.write(proxyData);
     };
     // Use if-elseif to prevent multiple writeBody/setHeader calls:
     // Error: "Cannot set headers after they are sent to the client"

package/dist/handlers/index.d.ts

@@ -1 +1 @@
-export * from './public';
+export * from './public.js';

package/dist/handlers/index.js

@@ -1,17 +1 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./public"), exports);
+export * from './public.js';

package/dist/handlers/public.d.ts

@@ -1,2 +1,2 @@
-export { responseInterceptor } from './response-interceptor';
-export { fixRequestBody } from './fix-request-body';
+export { responseInterceptor } from './response-interceptor.js';
+export { fixRequestBody } from './fix-request-body.js';

package/dist/handlers/public.js

@@ -1,7 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fixRequestBody = exports.responseInterceptor = void 0;
-var response_interceptor_1 = require("./response-interceptor");
-Object.defineProperty(exports, "responseInterceptor", { enumerable: true, get: function () { return response_interceptor_1.responseInterceptor; } });
-var fix_request_body_1 = require("./fix-request-body");
-Object.defineProperty(exports, "fixRequestBody", { enumerable: true, get: function () { return fix_request_body_1.fixRequestBody; } });
+export { responseInterceptor } from './response-interceptor.js';
+export { fixRequestBody } from './fix-request-body.js';

package/dist/handlers/response-interceptor.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.responseInterceptor = responseInterceptor;
-const zlib = require("node:zlib");
-const debug_1 = require("../debug");
-const function_1 = require("../utils/function");
-const debug = debug_1.Debug.extend('response-interceptor');
+import * as zlib from 'node:zlib';
+import { Debug } from '../debug.js';
+import { getFunctionName } from '../utils/function.js';
+const debug = Debug.extend('response-interceptor');
 /**
  * Intercept responses from upstream.
  * Automatically decompress (deflate, gzip, brotli).
@@ -12,7 +9,7 @@ const debug = debug_1.Debug.extend('response-interceptor');
  *
  * NOTE: must set options.selfHandleResponse=true (prevent automatic call of res.end())
  */
-function responseInterceptor(interceptor) {
+export function responseInterceptor(interceptor) {
     return async function proxyResResponseInterceptor(proxyRes, req, res) {
         debug('intercept proxy response');
         const originalProxyRes = proxyRes;
@@ -25,7 +22,7 @@ function responseInterceptor(interceptor) {
             // copy original headers
             copyHeaders(proxyRes, res);
             // call interceptor with intercepted response (buffer)
-            debug('call interceptor function: %s', (0, function_1.getFunctionName)(interceptor));
+            debug('call interceptor function: %s', getFunctionName(interceptor));
             const interceptedBuffer = Buffer.from(await interceptor(buffer, originalProxyRes, req, res));
             // set correct content-length (with double byte character support)
             debug('set content-length: %s', Buffer.byteLength(interceptedBuffer, 'utf8'));

package/dist/http-proxy-middleware.d.ts

@@ -1,5 +1,6 @@
-import type { Options, RequestHandler } from './types';
-export declare class HttpProxyMiddleware<TReq, TRes> {
+import type * as http from 'node:http';
+import type { Options, RequestHandler } from './types.js';
+export declare class HttpProxyMiddleware<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> {
     private wsInternalSubscribed;
     private serverOnCloseSubscribed;
     private proxyOptions;
@@ -7,7 +8,7 @@ export declare class HttpProxyMiddleware<TReq, TRes> {
     private pathRewriter;
     private logger;
     constructor(options: Options<TReq, TRes>);
-    middleware: RequestHandler;
+    middleware: RequestHandler<TReq, TRes>;
     private registerPlugins;
     private catchUpgradeRequest;
     private handleUpgrade;