Logo for jsDocs.io

webpack-dev-server

  • Version 5.2.0
  • Published
  • 541 kB
  • 27 dependencies
  • MIT license

Install

npm i webpack-dev-server
yarn add webpack-dev-server
pnpm add webpack-dev-server

Overview

Serves a webpack app. Updates the browser on changes.

Index

Functions

Classes

Type Aliases

Functions

function useFn

useFn: {
    (fn: NextHandleFunction): BasicApplication;
    (fn: HandleFunction): BasicApplication;
    (route: string, fn: NextHandleFunction): BasicApplication;
};

  • Parameter fn

    Returns

    {BasicApplication}

  • Parameter fn

    Returns

    {BasicApplication}

  • Parameter route

    Parameter fn

    Returns

    {BasicApplication}

Classes

class DEFAULT_STATS

class DEFAULT_STATS {}

    class Server

    class Server<
        A extends BasicApplication = import('express').Application,
        S extends BasicServer = import('http').Server<
            typeof import('http').IncomingMessage,
            typeof import('http').ServerResponse
        >
    > {}

    • {BasicApplication} [A=ExpressApplication] {BasicServer} [S=HTTPServer]

    constructor

    constructor(options: Configuration<A, S>, compiler: any);

    • Parameter options

      Parameter compiler

    property app

    app: BasicApplication;

    • {A | undefined}

    property compiler

    compiler: any;

      property isTlsServer

      isTlsServer: boolean;

        property logger

        logger: any;

        • {ReturnType<Compiler["getInfrastructureLogger"]>}

        property middleware

        middleware: any;

        • {import("webpack-dev-middleware").API<Request, Response>}

        property options

        options: Configuration<A, S>;

          property schema

          static readonly schema: {
              title: string;
              type: string;
              definitions: {
                  App: { instanceof: string; description: string; link: string };
                  AllowedHosts: {
                      anyOf: (
                          | {
                                type: string;
                                minItems: number;
                                items: { $ref: string };
                                enum?: undefined;
                                $ref?: undefined;
                            }
                          | {
                                enum: string[];
                                type?: undefined;
                                minItems?: undefined;
                                items?: undefined;
                                $ref?: undefined;
                            }
                          | {
                                $ref: string;
                                type?: undefined;
                                minItems?: undefined;
                                items?: undefined;
                                enum?: undefined;
                            }
                      )[];
                      description: string;
                      link: string;
                  };
                  AllowedHostsItem: { type: string; minLength: number };
                  Bonjour: {
                      anyOf: (
                          | {
                                type: string;
                                cli: { negatedDescription: string };
                                description?: undefined;
                                link?: undefined;
                            }
                          | {
                                type: string;
                                description: string;
                                link: string;
                                cli?: undefined;
                            }
                      )[];
                      description: string;
                      link: string;
                  };
                  Client: {
                      description: string;
                      link: string;
                      anyOf: (
                          | {
                                enum: boolean[];
                                cli: { negatedDescription: string };
                                type?: undefined;
                                additionalProperties?: undefined;
                                properties?: undefined;
                            }
                          | {
                                type: string;
                                additionalProperties: boolean;
                                properties: {
                                    logging: { $ref: string };
                                    overlay: { $ref: string };
                                    progress: { $ref: string };
                                    reconnect: { $ref: string };
                                    webSocketTransport: { $ref: string };
                                    webSocketURL: { $ref: string };
                                };
                                enum?: undefined;
                                cli?: undefined;
                            }
                      )[];
                  };
                  ClientLogging: { enum: string[]; description: string; link: string };
                  ClientOverlay: {
                      anyOf: (
                          | {
                                description: string;
                                link: string;
                                type: string;
                                cli: { negatedDescription: string };
                                additionalProperties?: undefined;
                                properties?: undefined;
                            }
                          | {
                                type: string;
                                additionalProperties: boolean;
                                properties: {
                                    errors: {
                                        anyOf: (
                                            | {
                                                  description: string;
                                                  type: string;
                                                  cli: { negatedDescription: string };
                                                  instanceof?: undefined;
                                              }
                                            | {
                                                  instanceof: string;
                                                  description: string;
                                                  type?: undefined;
                                                  cli?: undefined;
                                              }
                                        )[];
                                    };
                                    warnings: {
                                        anyOf: (
                                            | {
                                                  description: string;
                                                  type: string;
                                                  cli: { negatedDescription: string };
                                                  instanceof?: undefined;
                                              }
                                            | {
                                                  instanceof: string;
                                                  description: string;
                                                  type?: undefined;
                                                  cli?: undefined;
                                              }
                                        )[];
                                    };
                                    runtimeErrors: {
                                        anyOf: (
                                            | {
                                                  description: string;
                                                  type: string;
                                                  cli: { negatedDescription: string };
                                                  instanceof?: undefined;
                                              }
                                            | {
                                                  instanceof: string;
                                                  description: string;
                                                  type?: undefined;
                                                  cli?: undefined;
                                              }
                                        )[];
                                    };
                                    trustedTypesPolicyName: {
                                        description: string;
                                        type: string;
                                    };
                                };
                                description?: undefined;
                                link?: undefined;
                                cli?: undefined;
                            }
                      )[];
                  };
                  ClientProgress: {
                      description: string;
                      link: string;
                      type: string[];
                      enum: (string | boolean)[];
                      cli: { negatedDescription: string };
                  };
                  ClientReconnect: {
                      description: string;
                      link: string;
                      anyOf: (
                          | {
                                type: string;
                                cli: { negatedDescription: string };
                                minimum?: undefined;
                            }
                          | { type: string; minimum: number; cli?: undefined }
                      )[];
                  };
                  ClientWebSocketTransport: {
                      anyOf: { $ref: string }[];
                      description: string;
                      link: string;
                  };
                  ClientWebSocketTransportEnum: { enum: string[] };
                  ClientWebSocketTransportString: { type: string; minLength: number };
                  ClientWebSocketURL: {
                      description: string;
                      link: string;
                      anyOf: (
                          | {
                                type: string;
                                minLength: number;
                                additionalProperties?: undefined;
                                properties?: undefined;
                            }
                          | {
                                type: string;
                                additionalProperties: boolean;
                                properties: {
                                    hostname: {
                                        description: string;
                                        type: string;
                                        minLength: number;
                                    };
                                    pathname: { description: string; type: string };
                                    password: { description: string; type: string };
                                    port: {
                                        description: string;
                                        anyOf: (
                                            | { type: string; minLength?: undefined }
                                            | { type: string; minLength: number }
                                        )[];
                                    };
                                    protocol: {
                                        description: string;
                                        anyOf: (
                                            | {
                                                  enum: string[];
                                                  type?: undefined;
                                                  minLength?: undefined;
                                              }
                                            | {
                                                  type: string;
                                                  minLength: number;
                                                  enum?: undefined;
                                              }
                                        )[];
                                    };
                                    username: { description: string; type: string };
                                };
                                minLength?: undefined;
                            }
                      )[];
                  };
                  Compress: {
                      type: string;
                      description: string;
                      link: string;
                      cli: { negatedDescription: string };
                  };
                  DevMiddleware: {
                      description: string;
                      link: string;
                      type: string;
                      additionalProperties: boolean;
                  };
                  HeaderObject: {
                      type: string;
                      additionalProperties: boolean;
                      properties: {
                          key: { description: string; type: string };
                          value: { description: string; type: string };
                      };
                      cli: { exclude: boolean };
                  };
                  Headers: {
                      anyOf: (
                          | {
                                type: string;
                                items: { $ref: string };
                                minItems: number;
                                instanceof?: undefined;
                            }
                          | {
                                type: string;
                                items?: undefined;
                                minItems?: undefined;
                                instanceof?: undefined;
                            }
                          | {
                                instanceof: string;
                                type?: undefined;
                                items?: undefined;
                                minItems?: undefined;
                            }
                      )[];
                      description: string;
                      link: string;
                  };
                  HistoryApiFallback: {
                      anyOf: (
                          | {
                                type: string;
                                cli: { negatedDescription: string };
                                description?: undefined;
                                link?: undefined;
                            }
                          | {
                                type: string;
                                description: string;
                                link: string;
                                cli?: undefined;
                            }
                      )[];
                      description: string;
                      link: string;
                  };
                  Host: {
                      description: string;
                      link: string;
                      anyOf: (
                          | { enum: string[]; type?: undefined; minLength?: undefined }
                          | { type: string; minLength: number; enum?: undefined }
                      )[];
                  };
                  Hot: {
                      anyOf: (
                          | {
                                type: string;
                                cli: { negatedDescription: string };
                                enum?: undefined;
                            }
                          | { enum: string[]; type?: undefined; cli?: undefined }
                      )[];
                      description: string;
                      link: string;
                  };
                  IPC: {
                      anyOf: (
                          | { type: string; minLength: number; enum?: undefined }
                          | { type: string; enum: boolean[]; minLength?: undefined }
                      )[];
                      description: string;
                      link: string;
                  };
                  LiveReload: {
                      type: string;
                      description: string;
                      cli: { negatedDescription: string };
                      link: string;
                  };
                  OnListening: { instanceof: string; description: string; link: string };
                  Open: {
                      anyOf: (
                          | {
                                type: string;
                                items: { anyOf: { $ref: string }[] };
                                $ref?: undefined;
                            }
                          | { $ref: string; type?: undefined; items?: undefined }
                      )[];
                      description: string;
                      link: string;
                  };
                  OpenBoolean: { type: string; cli: { negatedDescription: string } };
                  OpenObject: {
                      type: string;
                      additionalProperties: boolean;
                      properties: {
                          target: {
                              anyOf: (
                                  | { type: string; items: { type: string } }
                                  | { type: string; items?: undefined }
                              )[];
                              description: string;
                          };
                          app: {
                              anyOf: (
                                  | {
                                        type: string;
                                        additionalProperties: boolean;
                                        properties: {
                                            name: {
                                                anyOf: (
                                                    | {
                                                          type: string;
                                                          items: {
                                                              type: string;
                                                              minLength: number;
                                                          };
                                                          minItems: number;
                                                          minLength?: undefined;
                                                      }
                                                    | {
                                                          type: string;
                                                          minLength: number;
                                                          items?: undefined;
                                                          minItems?: undefined;
                                                      }
                                                )[];
                                            };
                                            arguments: {
                                                items: { type: string; minLength: number };
                                            };
                                        };
                                        minLength?: undefined;
                                        description?: undefined;
                                        cli?: undefined;
                                    }
                                  | {
                                        type: string;
                                        minLength: number;
                                        description: string;
                                        cli: { exclude: boolean };
                                        additionalProperties?: undefined;
                                        properties?: undefined;
                                    }
                              )[];
                              description: string;
                          };
                      };
                  };
                  OpenString: { type: string; minLength: number };
                  Port: {
                      anyOf: (
                          | {
                                type: string;
                                minimum: number;
                                maximum: number;
                                minLength?: undefined;
                                enum?: undefined;
                            }
                          | {
                                type: string;
                                minLength: number;
                                minimum?: undefined;
                                maximum?: undefined;
                                enum?: undefined;
                            }
                          | {
                                enum: string[];
                                type?: undefined;
                                minimum?: undefined;
                                maximum?: undefined;
                                minLength?: undefined;
                            }
                      )[];
                      description: string;
                      link: string;
                  };
                  Proxy: {
                      type: string;
                      items: {
                          anyOf: (
                              | { type: string; instanceof?: undefined }
                              | { instanceof: string; type?: undefined }
                          )[];
                      };
                      description: string;
                      link: string;
                  };
                  Server: { anyOf: { $ref: string }[]; link: string; description: string };
                  ServerType: { enum: string[] };
                  ServerFn: { instanceof: string };
                  ServerEnum: { enum: string[]; cli: { exclude: boolean } };
                  ServerString: {
                      type: string;
                      minLength: number;
                      cli: { exclude: boolean };
                  };
                  ServerObject: {
                      type: string;
                      properties: {
                          type: { anyOf: { $ref: string }[] };
                          options: { $ref: string };
                      };
                      additionalProperties: boolean;
                  };
                  ServerOptions: {
                      type: string;
                      additionalProperties: boolean;
                      properties: {
                          passphrase: { type: string; description: string };
                          requestCert: {
                              type: string;
                              description: string;
                              cli: { negatedDescription: string };
                          };
                          ca: {
                              anyOf: (
                                  | {
                                        type: string;
                                        items: {
                                            anyOf: (
                                                | { type: string; instanceof?: undefined }
                                                | { instanceof: string; type?: undefined }
                                            )[];
                                        };
                                        instanceof?: undefined;
                                    }
                                  | {
                                        type: string;
                                        items?: undefined;
                                        instanceof?: undefined;
                                    }
                                  | {
                                        instanceof: string;
                                        type?: undefined;
                                        items?: undefined;
                                    }
                              )[];
                              description: string;
                          };
                          cert: {
                              anyOf: (
                                  | {
                                        type: string;
                                        items: {
                                            anyOf: (
                                                | { type: string; instanceof?: undefined }
                                                | { instanceof: string; type?: undefined }
                                            )[];
                                        };
                                        instanceof?: undefined;
                                    }
                                  | {
                                        type: string;
                                        items?: undefined;
                                        instanceof?: undefined;
                                    }
                                  | {
                                        instanceof: string;
                                        type?: undefined;
                                        items?: undefined;
                                    }
                              )[];
                              description: string;
                          };
                          crl: {
                              anyOf: (
                                  | {
                                        type: string;
                                        items: {
                                            anyOf: (
                                                | { type: string; instanceof?: undefined }
                                                | { instanceof: string; type?: undefined }
                                            )[];
                                        };
                                        instanceof?: undefined;
                                    }
                                  | {
                                        type: string;
                                        items?: undefined;
                                        instanceof?: undefined;
                                    }
                                  | {
                                        instanceof: string;
                                        type?: undefined;
                                        items?: undefined;
                                    }
                              )[];
                              description: string;
                          };
                          key: {
                              anyOf: (
                                  | {
                                        type: string;
                                        items: {
                                            anyOf: (
                                                | {
                                                      type: string;
                                                      instanceof?: undefined;
                                                      additionalProperties?: undefined;
                                                  }
                                                | {
                                                      instanceof: string;
                                                      type?: undefined;
                                                      additionalProperties?: undefined;
                                                  }
                                                | {
                                                      type: string;
                                                      additionalProperties: boolean;
                                                      instanceof?: undefined;
                                                  }
                                            )[];
                                        };
                                        instanceof?: undefined;
                                    }
                                  | {
                                        type: string;
                                        items?: undefined;
                                        instanceof?: undefined;
                                    }
                                  | {
                                        instanceof: string;
                                        type?: undefined;
                                        items?: undefined;
                                    }
                              )[];
                              description: string;
                          };
                          pfx: {
                              anyOf: (
                                  | {
                                        type: string;
                                        items: {
                                            anyOf: (
                                                | {
                                                      type: string;
                                                      instanceof?: undefined;
                                                      additionalProperties?: undefined;
                                                  }
                                                | {
                                                      instanceof: string;
                                                      type?: undefined;
                                                      additionalProperties?: undefined;
                                                  }
                                                | {
                                                      type: string;
                                                      additionalProperties: boolean;
                                                      instanceof?: undefined;
                                                  }
                                            )[];
                                        };
                                        instanceof?: undefined;
                                    }
                                  | {
                                        type: string;
                                        items?: undefined;
                                        instanceof?: undefined;
                                    }
                                  | {
                                        instanceof: string;
                                        type?: undefined;
                                        items?: undefined;
                                    }
                              )[];
                              description: string;
                          };
                      };
                  };
                  SetupExitSignals: {
                      type: string;
                      description: string;
                      link: string;
                      cli: { exclude: boolean };
                  };
                  SetupMiddlewares: {
                      instanceof: string;
                      description: string;
                      link: string;
                  };
                  Static: {
                      anyOf: (
                          | {
                                type: string;
                                items: { anyOf: { $ref: string }[] };
                                cli?: undefined;
                                $ref?: undefined;
                            }
                          | {
                                type: string;
                                cli: { negatedDescription: string };
                                items?: undefined;
                                $ref?: undefined;
                            }
                          | {
                                $ref: string;
                                type?: undefined;
                                items?: undefined;
                                cli?: undefined;
                            }
                      )[];
                      description: string;
                      link: string;
                  };
                  StaticObject: {
                      type: string;
                      additionalProperties: boolean;
                      properties: {
                          directory: {
                              type: string;
                              minLength: number;
                              description: string;
                              link: string;
                          };
                          staticOptions: {
                              type: string;
                              link: string;
                              additionalProperties: boolean;
                          };
                          publicPath: {
                              anyOf: (
                                  | {
                                        type: string;
                                        items: { type: string };
                                        minItems: number;
                                    }
                                  | {
                                        type: string;
                                        items?: undefined;
                                        minItems?: undefined;
                                    }
                              )[];
                              description: string;
                              link: string;
                          };
                          serveIndex: {
                              anyOf: (
                                  | {
                                        type: string;
                                        cli: { negatedDescription: string };
                                        additionalProperties?: undefined;
                                    }
                                  | {
                                        type: string;
                                        additionalProperties: boolean;
                                        cli?: undefined;
                                    }
                              )[];
                              description: string;
                              link: string;
                          };
                          watch: {
                              anyOf: (
                                  | {
                                        type: string;
                                        cli: { negatedDescription: string };
                                        description?: undefined;
                                        link?: undefined;
                                    }
                                  | {
                                        type: string;
                                        description: string;
                                        link: string;
                                        cli?: undefined;
                                    }
                              )[];
                              description: string;
                              link: string;
                          };
                      };
                  };
                  StaticString: { type: string; minLength: number };
                  WatchFiles: {
                      anyOf: (
                          | {
                                type: string;
                                items: { anyOf: { $ref: string }[] };
                                $ref?: undefined;
                            }
                          | { $ref: string; type?: undefined; items?: undefined }
                      )[];
                      description: string;
                      link: string;
                  };
                  WatchFilesObject: {
                      cli: { exclude: boolean };
                      type: string;
                      properties: {
                          paths: {
                              anyOf: (
                                  | {
                                        type: string;
                                        items: { type: string; minLength: number };
                                        minLength?: undefined;
                                    }
                                  | { type: string; minLength: number; items?: undefined }
                              )[];
                              description: string;
                          };
                          options: {
                              type: string;
                              description: string;
                              link: string;
                              additionalProperties: boolean;
                          };
                      };
                      additionalProperties: boolean;
                  };
                  WatchFilesString: { type: string; minLength: number };
                  WebSocketServer: {
                      anyOf: { $ref: string }[];
                      description: string;
                      link: string;
                  };
                  WebSocketServerType: { enum: string[] };
                  WebSocketServerEnum: {
                      anyOf: (
                          | {
                                enum: boolean[];
                                cli: { negatedDescription: string; exclude?: undefined };
                            }
                          | {
                                enum: string[];
                                cli: { exclude: boolean; negatedDescription?: undefined };
                            }
                      )[];
                  };
                  WebSocketServerFunction: { instanceof: string };
                  WebSocketServerObject: {
                      type: string;
                      properties: {
                          type: { anyOf: { $ref: string }[] };
                          options: {
                              type: string;
                              additionalProperties: boolean;
                              cli: { exclude: boolean };
                          };
                      };
                      additionalProperties: boolean;
                  };
                  WebSocketServerString: {
                      type: string;
                      minLength: number;
                      cli: { exclude: boolean };
                  };
              };
              additionalProperties: boolean;
              properties: {
                  allowedHosts: { $ref: string };
                  bonjour: { $ref: string };
                  client: { $ref: string };
                  compress: { $ref: string };
                  devMiddleware: { $ref: string };
                  headers: { $ref: string };
                  historyApiFallback: { $ref: string };
                  host: { $ref: string };
                  hot: { $ref: string };
                  ipc: { $ref: string };
                  liveReload: { $ref: string };
                  onListening: { $ref: string };
                  open: { $ref: string };
                  port: { $ref: string };
                  proxy: { $ref: string };
                  server: { $ref: string };
                  app: { $ref: string };
                  setupExitSignals: { $ref: string };
                  setupMiddlewares: { $ref: string };
                  static: { $ref: string };
                  watchFiles: { $ref: string };
                  webSocketServer: { $ref: string };
              };
          };

            property server

            server: {};

            • {S | undefined}

            property sockets

            sockets: any[];

            • {Socket[]}

            property staticWatchers

            staticWatchers: any[];

            • {FSWatcher[]}

            property webSocketServer

            webSocketServer: WebSocketServerImplementation;

            • {WebSocketServerImplementation | undefined | null}

            method findCacheDir

            static findCacheDir: () => string;

            • Returns

              {string}

            method findIp

            static findIp: (
                gatewayOrFamily: string,
                isInternal?: boolean
            ) => string | undefined;

            • Parameter gatewayOrFamily

              or family

              Parameter isInternal

              ip should be internal

              Returns

              {string | undefined}

            method getClientEntry

            getClientEntry: () => string;

            • Returns

              {string}

            method getClientHotEntry

            getClientHotEntry: () => string | void;

            • Returns

              {string | void}

            method getFreePort

            static getFreePort: (port: Port, host: string) => Promise<number | string>;

            • Parameter port

              Parameter host

              Returns

              {Promise<number | string>}

            method getHostname

            static getHostname: (hostname: Host) => Promise<string>;

            • Parameter hostname

              Returns

              {Promise}

            method internalIP

            static internalIP: (family: 'v4' | 'v6') => Promise<string | undefined>;

            • Parameter family

              Returns

              {Promise<string | undefined>}

            method internalIPSync

            static internalIPSync: (family: 'v4' | 'v6') => string | undefined;

            • Parameter family

              Returns

              {string | undefined}

            method invalidate

            invalidate: (callback?: any) => void;

            • Parameter callback

            method isAbsoluteURL

            static isAbsoluteURL: (URL: string) => boolean;

            • Parameter URL

              Returns

              {boolean}

            method sendMessage

            sendMessage: (
                clients: ClientConnection[],
                type: string,
                data?: any,
                params?: any
            ) => void;

            • Parameter clients

              Parameter type

              Parameter data

              Parameter params

            method start

            start: () => Promise<void>;

            • Returns

              {Promise}

            method startCallback

            startCallback: (callback?: (err?: Error) => void) => void;

            • Parameter callback

            method stop

            stop: () => Promise<void>;

            • Returns

              {Promise}

            method stopCallback

            stopCallback: (callback?: (err?: Error) => void) => void;

            • Parameter callback

            method watchFiles

            watchFiles: (watchPath: string | string[], watchOptions?: any) => void;

            • Parameter watchPath

              Parameter watchOptions

            Type Aliases

            type BasicApplication

            type BasicApplication = {
                use: typeof useFn;
            };

              type BasicServer

              type BasicServer = import('net').Server | import('tls').Server;

                type Bonjour

                type Bonjour = import('bonjour-service').Bonjour;

                  type BonjourOptions

                  type BonjourOptions = import('bonjour-service').Service;

                    type ByPass

                    type ByPass = (
                        req: Request,
                        res: Response,
                        proxyConfig: ProxyConfigArrayItem
                    ) => any;

                      type ClientConfiguration

                      type ClientConfiguration = {
                          logging?: 'none' | 'error' | 'warn' | 'info' | 'log' | 'verbose' | undefined;
                          overlay?:
                              | boolean
                              | {
                                    warnings?: OverlayMessageOptions;
                                    errors?: OverlayMessageOptions;
                                    runtimeErrors?: OverlayMessageOptions;
                                }
                              | undefined;
                          progress?: boolean | undefined;
                          reconnect?: number | boolean | undefined;
                          webSocketTransport?: string | undefined;
                          webSocketURL?: string | WebSocketURL | undefined;
                      };

                        type ClientConnection

                        type ClientConnection = (
                            | import('ws').WebSocket
                            | (import('sockjs').Connection & {
                                  send: import('ws').WebSocket['send'];
                                  terminate: import('ws').WebSocket['terminate'];
                                  ping: import('ws').WebSocket['ping'];
                              })
                        ) & {
                            isAlive?: boolean;
                        };

                          type Compiler

                          type Compiler = import('webpack').Compiler;

                            type Configuration

                            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;
                                hot?: boolean | 'only' | undefined;
                                liveReload?: boolean | undefined;
                                devMiddleware?:
                                    | DevMiddlewareOptions<
                                          import('express').Request<
                                              import('express-serve-static-core').ParamsDictionary,
                                              any,
                                              any,
                                              qs.ParsedQs,
                                              Record<string, any>
                                          >,
                                          import('express').Response<any, Record<string, any>>
                                      >
                                    | undefined;
                                compress?: boolean | undefined;
                                allowedHosts?: string | string[] | undefined;
                                historyApiFallback?:
                                    | boolean
                                    | import('connect-history-api-fallback').Options
                                    | undefined;
                                bonjour?:
                                    | boolean
                                    | Record<string, never>
                                    | import('bonjour-service').Service
                                    | undefined;
                                watchFiles?:
                                    | string
                                    | string[]
                                    | WatchFiles
                                    | (string | WatchFiles)[]
                                    | undefined;
                                static?: string | boolean | Static | (string | Static)[] | 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;
                                setupExitSignals?: boolean | undefined;
                                client?: boolean | ClientConfiguration | undefined;
                                headers?:
                                    | Headers
                                    | ((
                                          req: Request,
                                          res: Response,
                                          context: DevMiddlewareContext<Request, Response> | undefined
                                      ) => Headers)
                                    | undefined;
                                onListening?: ((devServer: Server<A, S>) => void) | undefined;
                                setupMiddlewares?:
                                    | ((middlewares: Middleware[], devServer: Server<A, S>) => Middleware[])
                                    | undefined;
                            };

                              type ConnectHistoryApiFallbackOptions

                              type ConnectHistoryApiFallbackOptions =
                                  import('connect-history-api-fallback').Options;

                                type DevMiddlewareContext

                                type DevMiddlewareContext<
                                    T extends Request,
                                    U extends Response
                                > = import('webpack-dev-middleware').Context<T, U>;

                                  type DevMiddlewareOptions

                                  type DevMiddlewareOptions<
                                      T extends Request,
                                      U extends Response
                                  > = import('webpack-dev-middleware').Options<T, U>;

                                    type ErrorHandleFunction

                                    type ErrorHandleFunction = (
                                        err: any,
                                        req: IncomingMessage,
                                        res: ServerResponse,
                                        next: NextFunction
                                    ) => void;

                                      type ExpressApplication

                                      type ExpressApplication = import('express').Application;

                                        type ExpressErrorRequestHandler

                                        type ExpressErrorRequestHandler = import('express').ErrorRequestHandler;

                                          type ExpressRequest

                                          type ExpressRequest = import('express').Request;

                                            type ExpressRequestHandler

                                            type ExpressRequestHandler = import('express').RequestHandler;

                                              type ExpressResponse

                                              type ExpressResponse = import('express').Response;

                                                type FSWatcher

                                                type FSWatcher = import('chokidar').FSWatcher;

                                                  type HandleFunction

                                                  type HandleFunction =
                                                      | SimpleHandleFunction
                                                      | NextHandleFunction
                                                      | ErrorHandleFunction;

                                                    type Headers

                                                    type Headers =
                                                        | Array<{
                                                              key: string;
                                                              value: string;
                                                          }>
                                                        | Record<string, string | string[]>;

                                                      type Host

                                                      type Host = 'local-ip' | 'local-ipv4' | 'local-ipv6' | string;

                                                        type HttpProxyMiddlewareOptions

                                                        type HttpProxyMiddlewareOptions = import('http-proxy-middleware').Options;

                                                          type HttpProxyMiddlewareOptionsFilter

                                                          type HttpProxyMiddlewareOptionsFilter = import('http-proxy-middleware').Filter;

                                                            type HTTPServer

                                                            type HTTPServer = import('http').Server;

                                                              type IncomingMessage

                                                              type IncomingMessage = import('http').IncomingMessage;

                                                                type IPv4

                                                                type IPv4 = import('ipaddr.js').IPv4;

                                                                  type IPv6

                                                                  type IPv6 = import('ipaddr.js').IPv6;

                                                                    type Middleware

                                                                    type Middleware = MiddlewareObject | MiddlewareHandler;

                                                                      type MiddlewareHandler

                                                                      type MiddlewareHandler<T extends BasicApplication = import('express').Application> =
                                                                          T extends ExpressApplication
                                                                              ? ExpressRequestHandler | ExpressErrorRequestHandler
                                                                              : HandleFunction;

                                                                        type MiddlewareObject

                                                                        type MiddlewareObject = {
                                                                            name?: string;
                                                                            path?: string;
                                                                            middleware: MiddlewareHandler;
                                                                        };

                                                                          type MultiCompiler

                                                                          type MultiCompiler = import('webpack').MultiCompiler;

                                                                            type MultiStats

                                                                            type MultiStats = import('webpack').MultiStats;

                                                                              type NetworkInterfaceInfo

                                                                              type NetworkInterfaceInfo = import('os').NetworkInterfaceInfo;

                                                                                type NextFunction

                                                                                type NextFunction = (err?: any) => void;

                                                                                  type NextHandleFunction

                                                                                  type NextHandleFunction = (
                                                                                      req: IncomingMessage,
                                                                                      res: ServerResponse,
                                                                                      next: NextFunction
                                                                                  ) => void;

                                                                                    type NormalizedOpen

                                                                                    type NormalizedOpen = {
                                                                                        target: string;
                                                                                        options: import('open').Options;
                                                                                    };

                                                                                      type NormalizedStatic

                                                                                      type NormalizedStatic = {
                                                                                          directory: string;
                                                                                          publicPath: string[];
                                                                                          serveIndex: false | ServeIndexOptions;
                                                                                          staticOptions: ServeStaticOptions;
                                                                                          watch: false | WatchOptions;
                                                                                      };

                                                                                        type Open

                                                                                        type Open = {
                                                                                            app?: string | string[] | OpenApp | undefined;
                                                                                            target?: string | string[] | undefined;
                                                                                        };

                                                                                          type OpenApp

                                                                                          type OpenApp = {
                                                                                              name?: string | undefined;
                                                                                              arguments?: string[] | undefined;
                                                                                          };

                                                                                            type OpenOptions

                                                                                            type OpenOptions = import('open').Options;

                                                                                              type OverlayMessageOptions

                                                                                              type OverlayMessageOptions = boolean | ((error: Error) => void);

                                                                                                type Port

                                                                                                type Port = number | string | 'auto';

                                                                                                  type ProxyConfigArray

                                                                                                  type ProxyConfigArray = (
                                                                                                      | ProxyConfigArrayItem
                                                                                                      | ((
                                                                                                            req?: Request | undefined,
                                                                                                            res?: Response | undefined,
                                                                                                            next?: NextFunction | undefined
                                                                                                        ) => ProxyConfigArrayItem)
                                                                                                  )[];

                                                                                                    type ProxyConfigArrayItem

                                                                                                    type ProxyConfigArrayItem = {
                                                                                                        path?: HttpProxyMiddlewareOptionsFilter | undefined;
                                                                                                        context?: HttpProxyMiddlewareOptionsFilter | undefined;
                                                                                                    } & {
                                                                                                        bypass?: ByPass;
                                                                                                    } & HttpProxyMiddlewareOptions;

                                                                                                      type Request

                                                                                                      type Request<T extends BasicApplication = import('express').Application> =
                                                                                                          T extends ExpressApplication ? ExpressRequest : IncomingMessage;

                                                                                                        type RequestHandler

                                                                                                        type RequestHandler = import('http-proxy-middleware').RequestHandler;

                                                                                                          type Response

                                                                                                          type Response<T extends BasicApplication = import('express').Application> =
                                                                                                              T extends ExpressApplication ? ExpressResponse : ServerResponse;

                                                                                                            type Schema

                                                                                                            type Schema = import('schema-utils/declarations/validate').Schema;

                                                                                                              type ServeIndexOptions

                                                                                                              type ServeIndexOptions = import('serve-index').Options;

                                                                                                                type ServerConfiguration

                                                                                                                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 ServerOptions

                                                                                                                  type ServerOptions = import('https').ServerOptions & {
                                                                                                                      spdy?: {
                                                                                                                          plain?: boolean | undefined;
                                                                                                                          ssl?: boolean | undefined;
                                                                                                                          'x-forwarded-for'?: string | undefined;
                                                                                                                          protocol?: string | undefined;
                                                                                                                          protocols?: string[] | undefined;
                                                                                                                      };
                                                                                                                  };

                                                                                                                    type ServerResponse

                                                                                                                    type ServerResponse = import('http').ServerResponse;

                                                                                                                      type ServerType

                                                                                                                      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 ServeStaticOptions

                                                                                                                        type ServeStaticOptions = import('serve-static').ServeStaticOptions;

                                                                                                                          type SimpleHandleFunction

                                                                                                                          type SimpleHandleFunction = (req: IncomingMessage, res: ServerResponse) => void;

                                                                                                                            type Socket

                                                                                                                            type Socket = import('net').Socket;

                                                                                                                              type Static

                                                                                                                              type Static = {
                                                                                                                                  directory?: string | undefined;
                                                                                                                                  publicPath?: string | string[] | undefined;
                                                                                                                                  serveIndex?: boolean | import('serve-index').Options | undefined;
                                                                                                                                  staticOptions?:
                                                                                                                                      | import('serve-static').ServeStaticOptions<
                                                                                                                                            import('http').ServerResponse<import('http').IncomingMessage>
                                                                                                                                        >
                                                                                                                                      | undefined;
                                                                                                                                  watch?:
                                                                                                                                      | boolean
                                                                                                                                      | (import('chokidar').WatchOptions & {
                                                                                                                                            aggregateTimeout?: number;
                                                                                                                                            ignored?: WatchOptions['ignored'];
                                                                                                                                            poll?: number | boolean;
                                                                                                                                        })
                                                                                                                                      | undefined;
                                                                                                                              };

                                                                                                                                type Stats

                                                                                                                                type Stats = import('webpack').Stats;

                                                                                                                                  type StatsCompilation

                                                                                                                                  type StatsCompilation = import('webpack').StatsCompilation;

                                                                                                                                    type StatsOptions

                                                                                                                                    type StatsOptions = import('webpack').StatsOptions;

                                                                                                                                      type WatchFiles

                                                                                                                                      type WatchFiles = {
                                                                                                                                          paths: string | string[];
                                                                                                                                          options?:
                                                                                                                                              | (import('chokidar').WatchOptions & {
                                                                                                                                                    aggregateTimeout?: number;
                                                                                                                                                    ignored?: WatchOptions['ignored'];
                                                                                                                                                    poll?: number | boolean;
                                                                                                                                                })
                                                                                                                                              | undefined;
                                                                                                                                      };

                                                                                                                                        type WatchOptions

                                                                                                                                        type WatchOptions = import('chokidar').WatchOptions;

                                                                                                                                          type WebpackConfiguration

                                                                                                                                          type WebpackConfiguration = import('webpack').Configuration;

                                                                                                                                            type WebSocketServer

                                                                                                                                            type WebSocketServer =
                                                                                                                                                | import('ws').WebSocketServer
                                                                                                                                                | (import('sockjs').Server & {
                                                                                                                                                      close: import('ws').WebSocketServer['close'];
                                                                                                                                                  });

                                                                                                                                              type WebSocketServerConfiguration

                                                                                                                                              type WebSocketServerConfiguration = {
                                                                                                                                                  type?: string | Function | undefined;
                                                                                                                                                  options?: Record<string, any> | undefined;
                                                                                                                                              };

                                                                                                                                                type WebSocketServerImplementation

                                                                                                                                                type WebSocketServerImplementation = {
                                                                                                                                                    implementation: WebSocketServer;
                                                                                                                                                    clients: ClientConnection[];
                                                                                                                                                };

                                                                                                                                                  type WebSocketURL

                                                                                                                                                  type WebSocketURL = {
                                                                                                                                                      hostname?: string | undefined;
                                                                                                                                                      password?: string | undefined;
                                                                                                                                                      pathname?: string | undefined;
                                                                                                                                                      port?: string | number | undefined;
                                                                                                                                                      protocol?: string | undefined;
                                                                                                                                                      username?: string | undefined;
                                                                                                                                                  };

                                                                                                                                                    Package Files (1)

                                                                                                                                                    Dependencies (27)

                                                                                                                                                    Dev Dependencies (57)

                                                                                                                                                    Peer Dependencies (1)

                                                                                                                                                    Badge

                                                                                                                                                    To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                    You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/webpack-dev-server.

                                                                                                                                                    • Markdown
                                                                                                                                                      [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/webpack-dev-server)
                                                                                                                                                    • HTML
                                                                                                                                                      <a href="https://www.jsdocs.io/package/webpack-dev-server"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>