• Version 3.11.5
  • Published
  • 21.3 kB
  • 5 dependencies
  • MIT license


npm i @types/webpack-dev-server
yarn add @types/webpack-dev-server
pnpm add @types/webpack-dev-server


TypeScript definitions for webpack-dev-server



class WebpackDevServer

class WebpackDevServer {}


    constructor(webpack: any, config?: WebpackDevServer.Configuration);

      property listeningApp

      listeningApp: WebpackDevServer.ListeningApp;

        property sockets

        sockets: any[];

          method addDevServerEntrypoints

          static addDevServerEntrypoints: (
          webpackOptions: webpack.Configuration | webpack.Configuration[],
          config: WebpackDevServer.Configuration,
          listeningApp?: WebpackDevServer.ListeningApp
          ) => void;

            method close

            close: (callback?: () => void) => void;

              method listen

              listen: {
              (port: number, hostname: string, callback?: (error?: Error) => void): any;
              (port: number, callback?: (error?: Error) => void): any;

                method sockWrite

                sockWrite: (sockets: NodeJS.EventEmitter[], type: string, data?: any) => void;


                  interface Configuration

                  interface Configuration {}

                    property after

                    | ((
                    app: express.Application,
                    server: WebpackDevServer,
                    compiler: webpack.Compiler
                    ) => void)
                    | undefined;
                    • Provides the ability to execute custom middleware after all other middleware internally within the server.

                    property allowedHosts

                    allowedHosts?: string[] | undefined;
                    • This option allows you to whitelist services that are allowed to access the dev server.

                    property before

                    | ((
                    app: express.Application,
                    server: WebpackDevServer,
                    compiler: webpack.Compiler
                    ) => void)
                    | undefined;
                    • Provides the ability to execute custom middleware prior to all other middleware internally within the server.

                    property bonjour

                    bonjour?: boolean | undefined;
                    • This option broadcasts the server via ZeroConf networking on start.

                    property clientLogLevel

                    | 'silent'
                    | 'trace'
                    | 'debug'
                    | 'info'
                    | 'warn'
                    | 'error'
                    | 'none'
                    | 'warning'
                    | undefined;
                    • When using inline mode, the console in your DevTools will show you messages e.g. before reloading, before an error or when Hot Module Replacement is enabled. This may be too verbose.

                      'none' and 'warning' are going to be deprecated at the next major version.

                    property compress

                    compress?: boolean | undefined;
                    • Enable gzip compression for everything served.

                    property contentBase

                    contentBase?: boolean | string | string[] | number | undefined;
                    • Tell the server where to serve content from. This is only necessary if you want to serve static files. devServer.publicPath will be used to determine where the bundles should be served from, and takes precedence.

                    property contentBasePublicPath

                    contentBasePublicPath?: string | string[] | undefined;
                    • Tell the server at what URL to serve devServer.contentBase. If there was a file assets/manifest.json, it would be served at /serve-content-base-at-this-url/manifest.json

                    property disableHostCheck

                    disableHostCheck?: boolean | undefined;
                    • When set to true this option bypasses host checking. THIS IS NOT RECOMMENDED as apps that do not check the host are vulnerable to DNS rebinding attacks.

                    property filename

                    filename?: string | undefined;
                    • This option lets you reduce the compilations in lazy mode. By default in lazy mode, every request results in a new compilation. With filename, it's possible to only compile when a certain file is requested.

                    property headers

                    | {
                    [key: string]: string;
                    | undefined;
                    • Adds headers to all responses.

                    property historyApiFallback

                    historyApiFallback?: boolean | connectHistoryApiFallback.Options | undefined;
                    • When using the HTML5 History API, the index.html page will likely have to be served in place of any 404 responses.

                    property host

                    host?: string | undefined;
                    • Specify a host to use. By default this is localhost.

                    property hot

                    hot?: boolean | undefined;
                    • Enable webpack's Hot Module Replacement feature. Note that webpack.HotModuleReplacementPlugin is required to fully enable HMR. If webpack or webpack-dev-server are launched with the --hot option, this plugin will be added automatically, so you may not need to add this to your webpack.config.js.

                    property hotOnly

                    hotOnly?: boolean | undefined;
                    • Enables Hot Module Replacement (see devServer.hot) without page refresh as fallback in case of build failures.

                    property http2

                    http2?: boolean | undefined;
                    • Serve over HTTP/2 using spdy. This option is ignored for Node 10.0.0 and above, as spdy is broken for those versions. The dev server will migrate over to Node's built-in HTTP/2 once Express supports it.

                    property https

                    https?: boolean | https.ServerOptions | undefined;
                    • By default dev-server will be served over HTTP. It can optionally be served over HTTP/2 with HTTPS.

                    property index

                    index?: string | undefined;
                    • The filename that is considered the index file.

                    property injectClient

                    | boolean
                    | ((compilerConfig: webpack.Compiler) => boolean)
                    | undefined;
                    • Tells devServer to inject a client. Setting devServer.injectClient to true will result in always injecting a client. It is possible to provide a function to inject conditionally

                    property injectHot

                    | boolean
                    | ((compilerConfig: webpack.Compiler) => boolean)
                    | undefined;
                    • Tells devServer to inject a Hot Module Replacement. Setting devServer.injectHot to true will result in always injecting. It is possible to provide a function to inject conditionally

                    property inline

                    inline?: boolean | undefined;
                    • Toggle between the dev-server's two different modes. By default the application will be served with inline mode enabled. This means that a script will be inserted in your bundle to take care of live reloading, and build messages will appear in the browser console.

                    property lazy

                    lazy?: boolean | undefined;
                    • When lazy is enabled, the dev-server will only compile the bundle when it gets requested. This means that webpack will not watch any file changes.

                    property liveReload

                    liveReload?: boolean | undefined;
                    • By default, the dev-server will reload/refresh the page when file changes are detected. devServer.hot option must be disabled or devServer.watchContentBase option must be enabled in order for liveReload to take effect. Disable devServer.liveReload by setting it to false

                    property mimeTypes

                    | {
                    [key: string]: string[];
                    | {
                    | ({
                    [key: string]: string[];
                    } & {
                    force: boolean;
                    | undefined;
                    | undefined;
                    • The object is passed to the underlying webpack-dev-middleware. See [documentation](https://github.com/webpack/webpack-dev-middleware#mimetypes) for usage notes.

                    property noInfo

                    noInfo?: boolean | undefined;
                    • With noInfo enabled, messages like the webpack bundle information that is shown when starting up and after each save,will be hidden. Errors and warnings will still be shown.

                    property onListening

                    onListening?: ((server: WebpackDevServer) => void) | undefined;
                    • Provides an option to execute a custom function when webpack-dev-server starts listening for connections on a port.

                    property open

                    open?: boolean | string | object | undefined;
                    • When open is enabled, the dev server will open the browser.

                    property openPage

                    openPage?: string | string[] | undefined;
                    • Specify a page to navigate to when opening the browser.

                    property overlay

                    | boolean
                    | {
                    warnings?: boolean | undefined;
                    errors?: boolean | undefined;
                    | undefined;
                    • Shows a full-screen overlay in the browser when there are compiler errors or warnings. Disabled by default.

                    property pfx

                    pfx?: string | undefined;
                    • When used via the CLI, a path to an SSL .pfx file. If used in options, it should be the bytestream of the .pfx file.

                    property pfxPassphrase

                    pfxPassphrase?: string | undefined;
                    • The passphrase to a SSL PFX file.

                    property port

                    port?: number | undefined;
                    • Specify a port number to listen for requests on.

                    property proxy

                    proxy?: ProxyConfigMap | ProxyConfigArray | undefined;
                    • Proxying some URLs can be useful when you have a separate API backend development server and you want to send API requests on the same domain.

                      The dev-server makes use of the powerful http-proxy-middleware package. Check out its [documentation](https://github.com/chimurai/http-proxy-middleware#options) for more advanced usages. Note that some of http-proxy-middleware's features do not require a target key, e.g. its router feature, but you will still need to include a target key in your config here, otherwise webpack-dev-server won't pass it along to http-proxy-middleware).

                    property public

                    public?: string | undefined;
                    • When using inline mode and you're proxying dev-server, the inline client script does not always know where to connect to. It will try to guess the URL of the server based on window.location, but if that fails you'll need to use this.

                    property publicPath

                    publicPath?: string | undefined;
                    • The bundled files will be available in the browser under this path. default is '/'

                    property quiet

                    quiet?: boolean | undefined;
                    • With quiet enabled, nothing except the initial startup information will be written to the console. This also means that errors or warnings from webpack are not visible.

                    property serveIndex

                    serveIndex?: boolean | undefined;
                    • Tells dev-server to use serveIndex middleware when enabled.

                      serveIndex middleware generates directory listings on viewing directories that don't have an index.html file.

                    property setup

                    | ((app: express.Application, server: WebpackDevServer) => void)
                    | undefined;
                    • Deprecated

                      This option is deprecated in favor of devServer.before and will be removed in v3.0.0. Here you can access the Express app object and add your own custom middleware to it.

                    property socket

                    socket?: string | undefined;
                    • The Unix socket to listen to (instead of a host).

                    property sockHost

                    sockHost?: string | undefined;
                    • Tells clients connected to devServer to use provided socket host.

                    property sockPath

                    sockPath?: string | undefined;
                    • The path at which to connect to the reloading socket. Default is '/sockjs-node'

                    property sockPort

                    sockPort?: string | number | undefined;
                    • Tells clients connected to devServer to use provided socket port.

                    property staticOptions

                    staticOptions?: serveStatic.ServeStaticOptions | undefined;
                    • It is possible to configure advanced options for serving static files from contentBase.

                      This only works when using devServer.contentBase as a string.

                    property stats

                    stats?: webpack.Configuration['stats'] | undefined;
                    • This option lets you precisely control what bundle information gets displayed. This can be a nice middle ground if you want some bundle information, but not all of it.

                    property transportMode

                    | 'sockjs'
                    | 'ws'
                    | {
                    client: object;
                    server: 'ws';
                    | {
                    client: 'ws';
                    server: object;
                    | {
                    client: object;
                    server: object;
                    | undefined;
                    • transportMode is an experimental option, meaning its usage could potentially change without warning.

                      Providing a string to devServer.transportMode is a shortcut to setting both devServer.transportMode.client and devServer.transportMode.server to the given string value.

                      This option allows us either to choose the current devServer transport mode for client/server individually or to provide custom client/server implementation. This allows to specify how browser or other client communicates with the devServer.

                      The current default mode is 'sockjs'. This mode uses SockJS-node as a server, and SockJS-client on the client.

                      'ws' mode will become the default mode in the next major devServer version. This mode uses ws as a server, and native WebSockets on the client.

                    property useLocalIp

                    useLocalIp?: boolean | undefined;
                    • This option lets the browser open with your local IP.

                    property watchContentBase

                    watchContentBase?: boolean | undefined;
                    • Tell the server to watch the files served by the devServer.contentBase option. File changes will trigger a full page reload.

                    property watchOptions

                    watchOptions?: webpack.Configuration['watchOptions'] | undefined;
                    • Control options related to watching the files.

                    property writeToDisk

                    writeToDisk?: boolean | ((filePath: string) => boolean) | undefined;
                    • Tells devServer to write generated assets to the disk.

                    interface ListeningApp

                    interface ListeningApp {}

                      method address

                      address: () => { port?: number | undefined };

                        interface ProxyConfigMap

                        interface ProxyConfigMap {}

                          index signature

                          [url: string]: string | httpProxyMiddleware.Options;

                            Type Aliases

                            type ProxyConfigArray

                            type ProxyConfigArray = ProxyConfigArrayItem[];

                              type ProxyConfigArrayItem

                              type ProxyConfigArrayItem = {
                              path?: string | string[] | undefined;
                              context?: string | string[] | httpProxyMiddleware.Filter | undefined;
                              } & httpProxyMiddleware.Options;

                                Package Files (1)

                                Dependencies (5)

                                Dev Dependencies (0)

                                No dev dependencies.

                                Peer Dependencies (0)

                                No peer dependencies.


                                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/@types/webpack-dev-server.

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