webpack-dev-server 5.0.4 → 5.2.0

package/types/lib/Server.d.ts

@@ -1,10 +1,28 @@
-/// <reference types="node" />
 export = Server;
-declare class Server {
+/**
+ * @typedef {Object} BasicApplication
+ * @property {typeof useFn} use
+ */
+/**
+ * @template {BasicApplication} [A=ExpressApplication]
+ * @template {BasicServer} [S=HTTPServer]
+ */
+declare class Server<
+  A extends BasicApplication = import("express").Application,
+  S extends BasicServer = import("http").Server<
+    typeof import("http").IncomingMessage,
+    typeof import("http").ServerResponse
+  >,
+> {
   static get schema(): {
     title: string;
     type: string;
     definitions: {
+      App: {
+        instanceof: string;
+        description: string;
+        link: string;
+      };
       AllowedHosts: {
         anyOf: (
           | {
@@ -49,7 +67,7 @@ declare class Server {
               link?: undefined;
             }
           | {
-              type: string /** @typedef {import("express").ErrorRequestHandler} ExpressErrorRequestHandler */;
+              type: string;
               description: string;
               link: string;
               cli?: undefined;
@@ -78,149 +96,6 @@ declare class Server {
                 logging: {
                   $ref: string;
                 };
-                /** @typedef {import("net").Socket} Socket */
-                /** @typedef {import("http").IncomingMessage} IncomingMessage */
-                /** @typedef {import("http").ServerResponse} ServerResponse */
-                /** @typedef {import("open").Options} OpenOptions */
-                /** @typedef {import("https").ServerOptions & { spdy?: { plain?: boolean | undefined, ssl?: boolean | undefined, 'x-forwarded-for'?: string | undefined, protocol?: string | undefined, protocols?: string[] | undefined }}} ServerOptions */
-                /** @typedef {import("express").Request} Request */
-                /** @typedef {import("express").Response} Response */
-                /**
-                 * @template {Request} T
-                 * @template {Response} U
-                 * @typedef {import("webpack-dev-middleware").Options<T, U>} DevMiddlewareOptions
-                 */
-                /**
-                 * @template {Request} T
-                 * @template {Response} U
-                 * @typedef {import("webpack-dev-middleware").Context<T, U>} DevMiddlewareContext
-                 */
-                /**
-                 * @typedef {"local-ip" | "local-ipv4" | "local-ipv6" | string} Host
-                 */
-                /**
-                 * @typedef {number | string | "auto"} Port
-                 */
-                /**
-                 * @typedef {Object} WatchFiles
-                 * @property {string | string[]} paths
-                 * @property {WatchOptions & { aggregateTimeout?: number, ignored?: WatchOptions["ignored"], poll?: number | boolean }} [options]
-                 */
-                /**
-                 * @typedef {Object} Static
-                 * @property {string} [directory]
-                 * @property {string | string[]} [publicPath]
-                 * @property {boolean | ServeIndexOptions} [serveIndex]
-                 * @property {ServeStaticOptions} [staticOptions]
-                 * @property {boolean | WatchOptions & { aggregateTimeout?: number, ignored?: WatchOptions["ignored"], poll?: number | boolean }} [watch]
-                 */
-                /**
-                 * @typedef {Object} NormalizedStatic
-                 * @property {string} directory
-                 * @property {string[]} publicPath
-                 * @property {false | ServeIndexOptions} serveIndex
-                 * @property {ServeStaticOptions} staticOptions
-                 * @property {false | WatchOptions} watch
-                 */
-                /**
-                 * @typedef {Object} ServerConfiguration
-                 * @property {"http" | "https" | "spdy" | string} [type]
-                 * @property {ServerOptions} [options]
-                 */
-                /**
-                 * @typedef {Object} WebSocketServerConfiguration
-                 * @property {"sockjs" | "ws" | string | Function} [type]
-                 * @property {Record<string, any>} [options]
-                 */
-                /**
-                 * @typedef {(import("ws").WebSocket | import("sockjs").Connection & { send: import("ws").WebSocket["send"], terminate: import("ws").WebSocket["terminate"], ping: import("ws").WebSocket["ping"] }) & { isAlive?: boolean }} ClientConnection
-                 */
-                /**
-                 * @typedef {import("ws").WebSocketServer | import("sockjs").Server & { close: import("ws").WebSocketServer["close"] }} WebSocketServer
-                 */
-                /**
-                 * @typedef {{ implementation: WebSocketServer, clients: ClientConnection[] }} WebSocketServerImplementation
-                 */
-                /**
-                 * @callback ByPass
-                 * @param {Request} req
-                 * @param {Response} res
-                 * @param {ProxyConfigArrayItem} proxyConfig
-                 */
-                /**
-                 * @typedef {{ path?: HttpProxyMiddlewareOptionsFilter | undefined, context?: HttpProxyMiddlewareOptionsFilter | undefined } & { bypass?: ByPass } & HttpProxyMiddlewareOptions } ProxyConfigArrayItem
-                 */
-                /**
-                 * @typedef {(ProxyConfigArrayItem | ((req?: Request | undefined, res?: Response | undefined, next?: NextFunction | undefined) => ProxyConfigArrayItem))[]} ProxyConfigArray
-                 */
-                /**
-                 * @typedef {Object} OpenApp
-                 * @property {string} [name]
-                 * @property {string[]} [arguments]
-                 */
-                /**
-                 * @typedef {Object} Open
-                 * @property {string | string[] | OpenApp} [app]
-                 * @property {string | string[]} [target]
-                 */
-                /**
-                 * @typedef {Object} NormalizedOpen
-                 * @property {string} target
-                 * @property {import("open").Options} options
-                 */
-                /**
-                 * @typedef {Object} WebSocketURL
-                 * @property {string} [hostname]
-                 * @property {string} [password]
-                 * @property {string} [pathname]
-                 * @property {number | string} [port]
-                 * @property {string} [protocol]
-                 * @property {string} [username]
-                 */
-                /**
-                 * @typedef {boolean | ((error: Error) => void)} OverlayMessageOptions
-                 */
-                /**
-                 * @typedef {Object} ClientConfiguration
-                 * @property {"log" | "info" | "warn" | "error" | "none" | "verbose"} [logging]
-                 * @property {boolean  | { warnings?: OverlayMessageOptions, errors?: OverlayMessageOptions, runtimeErrors?: OverlayMessageOptions }} [overlay]
-                 * @property {boolean} [progress]
-                 * @property {boolean | number} [reconnect]
-                 * @property {"ws" | "sockjs" | string} [webSocketTransport]
-                 * @property {string | WebSocketURL} [webSocketURL]
-                 */
-                /**
-                 * @typedef {Array<{ key: string; value: string }> | Record<string, string | string[]>} Headers
-                 */
-                /**
-                 * @typedef {{ name?: string, path?: string, middleware: ExpressRequestHandler | ExpressErrorRequestHandler } | ExpressRequestHandler | ExpressErrorRequestHandler} Middleware
-                 */
-                /**
-                 * @typedef {Object} Configuration
-                 * @property {boolean | string} [ipc]
-                 * @property {Host} [host]
-                 * @property {Port} [port]
-                 * @property {boolean | "only"} [hot]
-                 * @property {boolean} [liveReload]
-                 * @property {DevMiddlewareOptions<Request, Response>} [devMiddleware]
-                 * @property {boolean} [compress]
-                 * @property {"auto" | "all" | string | string[]} [allowedHosts]
-                 * @property {boolean | ConnectHistoryApiFallbackOptions} [historyApiFallback]
-                 * @property {boolean | Record<string, never> | BonjourOptions} [bonjour]
-                 * @property {string | string[] | WatchFiles | Array<string | WatchFiles>} [watchFiles]
-                 * @property {boolean | string | Static | Array<string | Static>} [static]
-                 * @property {boolean | ServerOptions} [https]
-                 * @property {boolean} [http2]
-                 * @property {"http" | "https" | "spdy" | string | ServerConfiguration} [server]
-                 * @property {boolean | "sockjs" | "ws" | string | WebSocketServerConfiguration} [webSocketServer]
-                 * @property {ProxyConfigArray} [proxy]
-                 * @property {boolean | string | Open | Array<string | Open>} [open]
-                 * @property {boolean} [setupExitSignals]
-                 * @property {boolean | ClientConfiguration} [client]
-                 * @property {Headers | ((req: Request, res: Response, context: DevMiddlewareContext<Request, Response>) => Headers)} [headers]
-                 * @property {(devServer: Server) => void} [onListening]
-                 * @property {(middlewares: Middleware[], devServer: Server) => Middleware[]} [setupMiddlewares]
-                 */
                 overlay: {
                   $ref: string;
                 };
@@ -292,9 +167,7 @@ declare class Server {
                         instanceof?: undefined;
                       }
                     | {
-                        instanceof: string /**
-                         * @typedef {import("ws").WebSocketServer | import("sockjs").Server & { close: import("ws").WebSocketServer["close"] }} WebSocketServer
-                         */;
+                        instanceof: string;
                         description: string;
                         type?: undefined;
                         cli?: undefined;
@@ -333,7 +206,8 @@ declare class Server {
       ClientProgress: {
         description: string;
         link: string;
-        type: string;
+        type: string[];
+        enum: (string | boolean)[];
         cli: {
           negatedDescription: string;
         };
@@ -357,35 +231,6 @@ declare class Server {
         )[];
       };
       ClientWebSocketTransport: {
-        /**
-         * @typedef {{ name?: string, path?: string, middleware: ExpressRequestHandler | ExpressErrorRequestHandler } | ExpressRequestHandler | ExpressErrorRequestHandler} Middleware
-         */
-        /**
-         * @typedef {Object} Configuration
-         * @property {boolean | string} [ipc]
-         * @property {Host} [host]
-         * @property {Port} [port]
-         * @property {boolean | "only"} [hot]
-         * @property {boolean} [liveReload]
-         * @property {DevMiddlewareOptions<Request, Response>} [devMiddleware]
-         * @property {boolean} [compress]
-         * @property {"auto" | "all" | string | string[]} [allowedHosts]
-         * @property {boolean | ConnectHistoryApiFallbackOptions} [historyApiFallback]
-         * @property {boolean | Record<string, never> | BonjourOptions} [bonjour]
-         * @property {string | string[] | WatchFiles | Array<string | WatchFiles>} [watchFiles]
-         * @property {boolean | string | Static | Array<string | Static>} [static]
-         * @property {boolean | ServerOptions} [https]
-         * @property {boolean} [http2]
-         * @property {"http" | "https" | "spdy" | string | ServerConfiguration} [server]
-         * @property {boolean | "sockjs" | "ws" | string | WebSocketServerConfiguration} [webSocketServer]
-         * @property {ProxyConfigArray} [proxy]
-         * @property {boolean | string | Open | Array<string | Open>} [open]
-         * @property {boolean} [setupExitSignals]
-         * @property {boolean | ClientConfiguration} [client]
-         * @property {Headers | ((req: Request, res: Response, context: DevMiddlewareContext<Request, Response>) => Headers)} [headers]
-         * @property {(devServer: Server) => void} [onListening]
-         * @property {(middlewares: Middleware[], devServer: Server) => Middleware[]} [setupMiddlewares]
-         */
         anyOf: {
           $ref: string;
         }[];
@@ -479,9 +324,6 @@ declare class Server {
       };
       HeaderObject: {
         type: string;
-        /**
-         * @type {FSWatcher[]}
-         */
         additionalProperties: boolean;
         properties: {
           key: {
@@ -731,7 +573,7 @@ declare class Server {
             }
         )[];
         description: string;
-        link: string /** @type {WebSocketURL} */;
+        link: string;
       };
       Proxy: {
         type: string;
@@ -743,7 +585,6 @@ declare class Server {
               }
             | {
                 instanceof: string;
-                /** @type {{ type: WebSocketServerConfiguration["type"], options: NonNullable<WebSocketServerConfiguration["options"]> }} */
                 type?: undefined;
               }
           )[];
@@ -761,6 +602,9 @@ declare class Server {
       ServerType: {
         enum: string[];
       };
+      ServerFn: {
+        instanceof: string;
+      };
       ServerEnum: {
         enum: string[];
         cli: {
@@ -770,7 +614,6 @@ declare class Server {
       ServerString: {
         type: string;
         minLength: number;
-        /** @type {string} */
         cli: {
           exclude: boolean;
         };
@@ -1259,6 +1102,9 @@ declare class Server {
       server: {
         $ref: string;
       };
+      app: {
+        $ref: string;
+      };
       setupExitSignals: {
         $ref: string;
       };
@@ -1282,10 +1128,14 @@ declare class Server {
    */
   static isAbsoluteURL(URL: string): boolean;
   /**
-   * @param {string} gateway
+   * @param {string} gatewayOrFamily or family
+   * @param {boolean} [isInternal] ip should be internal
    * @returns {string | undefined}
    */
-  static findIp(gateway: string): string | undefined;
+  static findIp(
+    gatewayOrFamily: string,
+    isInternal?: boolean,
+  ): string | undefined;
   /**
    * @param {"v4" | "v6"} family
    * @returns {Promise<string | undefined>}
@@ -1318,23 +1168,19 @@ declare class Server {
    */
   private static isWebTarget;
   /**
-   * @param {Configuration | Compiler | MultiCompiler} options
-   * @param {Compiler | MultiCompiler | Configuration} compiler
+   * @param {Configuration<A, S>} options
+   * @param {Compiler | MultiCompiler} compiler
    */
   constructor(
-    options:
-      | import("webpack").Compiler
-      | import("webpack").MultiCompiler
-      | Configuration
-      | undefined,
-    compiler: Compiler | MultiCompiler | Configuration,
+    options: Configuration<A, S> | undefined,
+    compiler: Compiler | MultiCompiler,
   );
   compiler: import("webpack").Compiler | import("webpack").MultiCompiler;
   /**
    * @type {ReturnType<Compiler["getInfrastructureLogger"]>}
    * */
   logger: ReturnType<Compiler["getInfrastructureLogger"]>;
-  options: Configuration;
+  options: Configuration<A, S>;
   /**
    * @type {FSWatcher[]}
    */
@@ -1379,10 +1225,19 @@ declare class Server {
    */
   private getClientTransport;
   /**
+   * @template T
    * @private
-   * @returns {string}
+   * @returns {T}
    */
   private getServerTransport;
+  /**
+   * @returns {string}
+   */
+  getClientEntry(): string;
+  /**
+   * @returns {string | void}
+   */
+  getClientHotEntry(): string | void;
   /**
    * @private
    * @returns {void}
@@ -1395,11 +1250,11 @@ declare class Server {
   private initialize;
   /**
    * @private
-   * @returns {void}
+   * @returns {Promise<void>}
    */
   private setupApp;
-  /** @type {import("express").Application | undefined}*/
-  app: import("express").Application | undefined;
+  /** @type {A | undefined}*/
+  app: A | undefined;
   /**
    * @private
    * @param {Stats | MultiStats} statsObj
@@ -1420,12 +1275,18 @@ declare class Server {
    * @private
    * @returns {void}
    */
-  private setupHostHeaderCheck;
+  private setupWatchStaticFiles;
+  /**
+   * @private
+   * @returns {void}
+   */
+  private setupWatchFiles;
   /**
    * @private
    * @returns {void}
    */
-  private setupDevMiddleware;
+  private setupMiddlewares;
+  /** @type {import("webpack-dev-middleware").API<Request, Response>} */
   middleware:
     | import("webpack-dev-middleware").API<
         import("express").Request<
@@ -1437,35 +1298,15 @@ declare class Server {
         >,
         import("express").Response<any, Record<string, any>>
       >
-    | null
     | undefined;
   /**
    * @private
-   * @returns {void}
-   */
-  private setupBuiltInRoutes;
-  /**
-   * @private
-   * @returns {void}
-   */
-  private setupWatchStaticFiles;
-  /**
-   * @private
-   * @returns {void}
-   */
-  private setupWatchFiles;
-  /**
-   * @private
-   * @returns {void}
-   */
-  private setupMiddlewares;
-  /**
-   * @private
-   * @returns {void}
+   * @returns {Promise<void>}
    */
   private createServer;
-  /** @type {import("http").Server | undefined | null} */
-  server: import("http").Server | undefined | null;
+  /** @type {S | undefined}*/
+  server: S | undefined;
+  isTlsServer: boolean | undefined;
   /**
    * @private
    * @returns {void}
@@ -1536,16 +1377,11 @@ declare class Server {
    * @param {string | string[]} watchPath
    * @param {WatchOptions} [watchOptions]
    */
-  watchFiles(
-    watchPath: string | string[],
-    watchOptions?: import("chokidar").WatchOptions | undefined,
-  ): void;
+  watchFiles(watchPath: string | string[], watchOptions?: WatchOptions): void;
   /**
    * @param {import("webpack-dev-middleware").Callback} [callback]
    */
-  invalidate(
-    callback?: import("webpack-dev-middleware").Callback | undefined,
-  ): void;
+  invalidate(callback?: import("webpack-dev-middleware").Callback): void;
   /**
    * @returns {Promise<void>}
    */
@@ -1553,7 +1389,7 @@ declare class Server {
   /**
    * @param {(err?: Error) => void} [callback]
    */
-  startCallback(callback?: ((err?: Error) => void) | undefined): void;
+  startCallback(callback?: (err?: Error) => void): void;
   /**
    * @returns {Promise<void>}
    */
@@ -1561,7 +1397,7 @@ declare class Server {
   /**
    * @param {(err?: Error) => void} [callback]
    */
-  stopCallback(callback?: ((err?: Error) => void) | undefined): void;
+  stopCallback(callback?: (err?: Error) => void): void;
 }
 declare namespace Server {
   export {
@@ -1575,9 +1411,6 @@ declare namespace Server {
     Stats,
     MultiStats,
     NetworkInterfaceInfo,
-    NextFunction,
-    ExpressRequestHandler,
-    ExpressErrorRequestHandler,
     WatchOptions,
     FSWatcher,
     ConnectHistoryApiFallbackOptions,
@@ -1591,9 +1424,20 @@ declare namespace Server {
     IPv4,
     IPv6,
     Socket,
+    HTTPServer,
     IncomingMessage,
     ServerResponse,
     OpenOptions,
+    ExpressApplication,
+    ExpressRequestHandler,
+    ExpressErrorRequestHandler,
+    ExpressRequest,
+    ExpressResponse,
+    NextFunction,
+    SimpleHandleFunction,
+    NextHandleFunction,
+    ErrorHandleFunction,
+    HandleFunction,
     ServerOptions,
     Request,
     Response,
@@ -1604,6 +1448,7 @@ declare namespace Server {
     WatchFiles,
     Static,
     NormalizedStatic,
+    ServerType,
     ServerConfiguration,
     WebSocketServerConfiguration,
     ClientConnection,
@@ -1619,21 +1464,19 @@ declare namespace Server {
     OverlayMessageOptions,
     ClientConfiguration,
     Headers,
+    MiddlewareHandler,
+    MiddlewareObject,
     Middleware,
+    BasicServer,
     Configuration,
+    BasicApplication,
   };
 }
-type Compiler = import("webpack").Compiler;
-type FSWatcher = import("chokidar").FSWatcher;
-type Socket = import("net").Socket;
-type WebSocketServerImplementation = {
-  implementation: WebSocketServer;
-  clients: ClientConnection[];
-};
 declare class DEFAULT_STATS {
   private constructor();
 }
 type Schema = import("schema-utils/declarations/validate").Schema;
+type Compiler = import("webpack").Compiler;
 type MultiCompiler = import("webpack").MultiCompiler;
 type WebpackConfiguration = import("webpack").Configuration;
 type StatsOptions = import("webpack").StatsOptions;
@@ -1641,10 +1484,8 @@ type StatsCompilation = import("webpack").StatsCompilation;
 type Stats = import("webpack").Stats;
 type MultiStats = import("webpack").MultiStats;
 type NetworkInterfaceInfo = import("os").NetworkInterfaceInfo;
-type NextFunction = import("express").NextFunction;
-type ExpressRequestHandler = import("express").RequestHandler;
-type ExpressErrorRequestHandler = import("express").ErrorRequestHandler;
 type WatchOptions = import("chokidar").WatchOptions;
+type FSWatcher = import("chokidar").FSWatcher;
 type ConnectHistoryApiFallbackOptions =
   import("connect-history-api-fallback").Options;
 type Bonjour = import("bonjour-service").Bonjour;
@@ -1656,9 +1497,33 @@ type ServeIndexOptions = import("serve-index").Options;
 type ServeStaticOptions = import("serve-static").ServeStaticOptions;
 type IPv4 = import("ipaddr.js").IPv4;
 type IPv6 = import("ipaddr.js").IPv6;
+type Socket = import("net").Socket;
+type HTTPServer = import("http").Server;
 type IncomingMessage = import("http").IncomingMessage;
 type ServerResponse = import("http").ServerResponse;
 type OpenOptions = import("open").Options;
+type ExpressApplication = import("express").Application;
+type ExpressRequestHandler = import("express").RequestHandler;
+type ExpressErrorRequestHandler = import("express").ErrorRequestHandler;
+type ExpressRequest = import("express").Request;
+type ExpressResponse = import("express").Response;
+type NextFunction = (err?: any) => void;
+type SimpleHandleFunction = (req: IncomingMessage, res: ServerResponse) => void;
+type NextHandleFunction = (
+  req: IncomingMessage,
+  res: ServerResponse,
+  next: NextFunction,
+) => void;
+type ErrorHandleFunction = (
+  err: any,
+  req: IncomingMessage,
+  res: ServerResponse,
+  next: NextFunction,
+) => void;
+type HandleFunction =
+  | SimpleHandleFunction
+  | NextHandleFunction
+  | ErrorHandleFunction;
 type ServerOptions = import("https").ServerOptions & {
   spdy?: {
     plain?: boolean | undefined;
@@ -1668,27 +1533,17 @@ type ServerOptions = import("https").ServerOptions & {
     protocols?: string[] | undefined;
   };
 };
-type Request = import("express").Request;
-type Response = import("express").Response;
+type Request<T extends BasicApplication = import("express").Application> =
+  T extends ExpressApplication ? ExpressRequest : IncomingMessage;
+type Response<T extends BasicApplication = import("express").Application> =
+  T extends ExpressApplication ? ExpressResponse : ServerResponse;
 type DevMiddlewareOptions<
-  T extends import("express").Request<
-    import("express-serve-static-core").ParamsDictionary,
-    any,
-    any,
-    qs.ParsedQs,
-    Record<string, any>
-  >,
-  U extends import("express").Response<any, Record<string, any>>,
+  T extends Request,
+  U extends Response,
 > = import("webpack-dev-middleware").Options<T, U>;
 type DevMiddlewareContext<
-  T extends import("express").Request<
-    import("express-serve-static-core").ParamsDictionary,
-    any,
-    any,
-    qs.ParsedQs,
-    Record<string, any>
-  >,
-  U extends import("express").Response<any, Record<string, any>>,
+  T extends Request,
+  U extends Response,
 > = import("webpack-dev-middleware").Context<T, U>;
 type Host = "local-ip" | "local-ipv4" | "local-ipv6" | string;
 type Port = number | string | "auto";
@@ -1696,9 +1551,9 @@ type WatchFiles = {
   paths: string | string[];
   options?:
     | (import("chokidar").WatchOptions & {
-        aggregateTimeout?: number | undefined;
+        aggregateTimeout?: number;
         ignored?: WatchOptions["ignored"];
-        poll?: number | boolean | undefined;
+        poll?: number | boolean;
       })
     | undefined;
 };
@@ -1714,9 +1569,9 @@ type Static = {
   watch?:
     | boolean
     | (import("chokidar").WatchOptions & {
-        aggregateTimeout?: number | undefined;
+        aggregateTimeout?: number;
         ignored?: WatchOptions["ignored"];
-        poll?: number | boolean | undefined;
+        poll?: number | boolean;
       })
     | undefined;
 };
@@ -1727,8 +1582,27 @@ type NormalizedStatic = {
   staticOptions: ServeStaticOptions;
   watch: false | WatchOptions;
 };
-type ServerConfiguration = {
-  type?: string | undefined;
+type ServerType<
+  A extends BasicApplication = import("express").Application,
+  S extends BasicServer = import("http").Server<
+    typeof import("http").IncomingMessage,
+    typeof import("http").ServerResponse
+  >,
+> =
+  | "http"
+  | "https"
+  | "spdy"
+  | "http2"
+  | string
+  | ((arg0: ServerOptions, arg1: A) => S);
+type ServerConfiguration<
+  A extends BasicApplication = import("express").Application,
+  S extends BasicServer = import("http").Server<
+    typeof import("http").IncomingMessage,
+    typeof import("http").ServerResponse
+  >,
+> = {
+  type?: ServerType<A, S> | undefined;
   options?: ServerOptions | undefined;
 };
 type WebSocketServerConfiguration = {
@@ -1750,6 +1624,10 @@ type WebSocketServer =
   | (import("sockjs").Server & {
       close: import("ws").WebSocketServer["close"];
     });
+type WebSocketServerImplementation = {
+  implementation: WebSocketServer;
+  clients: ClientConnection[];
+};
 type ByPass = (
   req: Request,
   res: Response,
@@ -1795,9 +1673,9 @@ type ClientConfiguration = {
   overlay?:
     | boolean
     | {
-        warnings?: OverlayMessageOptions | undefined;
-        errors?: OverlayMessageOptions | undefined;
-        runtimeErrors?: OverlayMessageOptions | undefined;
+        warnings?: OverlayMessageOptions;
+        errors?: OverlayMessageOptions;
+        runtimeErrors?: OverlayMessageOptions;
       }
     | undefined;
   progress?: boolean | undefined;
@@ -1811,15 +1689,25 @@ type Headers =
       value: string;
     }>
   | Record<string, string | string[]>;
-type Middleware =
-  | {
-      name?: string;
-      path?: string;
-      middleware: ExpressRequestHandler | ExpressErrorRequestHandler;
-    }
-  | ExpressRequestHandler
-  | ExpressErrorRequestHandler;
-type Configuration = {
+type MiddlewareHandler<
+  T extends BasicApplication = import("express").Application,
+> = T extends ExpressApplication
+  ? ExpressRequestHandler | ExpressErrorRequestHandler
+  : HandleFunction;
+type MiddlewareObject = {
+  name?: string;
+  path?: string;
+  middleware: MiddlewareHandler;
+};
+type Middleware = MiddlewareObject | MiddlewareHandler;
+type BasicServer = import("net").Server | import("tls").Server;
+type Configuration<
+  A extends BasicApplication = import("express").Application,
+  S extends BasicServer = import("http").Server<
+    typeof import("http").IncomingMessage,
+    typeof import("http").ServerResponse
+  >,
+> = {
   ipc?: string | boolean | undefined;
   host?: string | undefined;
   port?: Port | undefined;
@@ -1855,9 +1743,8 @@ type Configuration = {
     | (string | WatchFiles)[]
     | undefined;
   static?: string | boolean | Static | (string | Static)[] | undefined;
-  https?: boolean | ServerOptions | undefined;
-  http2?: boolean | undefined;
-  server?: string | ServerConfiguration | undefined;
+  server?: ServerType<A, S> | ServerConfiguration<A, S> | undefined;
+  app?: (() => Promise<A>) | undefined;
   webSocketServer?: string | boolean | WebSocketServerConfiguration | undefined;
   proxy?: ProxyConfigArray | undefined;
   open?: string | boolean | Open | (string | Open)[] | undefined;
@@ -1868,15 +1755,36 @@ type Configuration = {
     | ((
         req: Request,
         res: Response,
-        context: DevMiddlewareContext<Request, Response>,
+        context: DevMiddlewareContext<Request, Response> | undefined,
       ) => Headers)
     | undefined;
-  onListening?: ((devServer: Server) => void) | undefined;
+  onListening?: ((devServer: Server<A, S>) => void) | undefined;
   setupMiddlewares?:
-    | ((middlewares: Middleware[], devServer: Server) => Middleware[])
+    | ((middlewares: Middleware[], devServer: Server<A, S>) => Middleware[])
     | undefined;
 };
-import path = require("path");
+type BasicApplication = {
+  use: typeof useFn;
+};
+/**
+ * @overload
+ * @param {NextHandleFunction} fn
+ * @returns {BasicApplication}
+ */
+declare function useFn(fn: NextHandleFunction): BasicApplication;
+/**
+ * @overload
+ * @param {HandleFunction} fn
+ * @returns {BasicApplication}
+ */
+declare function useFn(fn: HandleFunction): BasicApplication;
+/**
+ * @overload
+ * @param {string} route
+ * @param {NextHandleFunction} fn
+ * @returns {BasicApplication}
+ */
+declare function useFn(route: string, fn: NextHandleFunction): BasicApplication;
 
 // DO NOT REMOVE THIS!
 type DevServerConfiguration = Configuration;