diff --git a/webpack/webpack.d.ts b/webpack/webpack.d.ts
index 9e0ae9e7f..5bf5050b8 100644
--- a/webpack/webpack.d.ts
+++ b/webpack/webpack.d.ts
@@ -8,25 +8,56 @@ declare module "webpack" {
         interface Configuration {
             context?: string;
             entry?: string|string[]|Entry;
+            /** Choose a developer tool to enhance debugging. */
             devtool?: string;
+            /** Options affecting the output. */
             output?: Output;
+            /** Options affecting the normal modules (NormalModuleFactory) */
             module?: Module;
+            /** Options affecting the resolving of modules. */
             resolve?: Resolve;
+            /** Like resolve but for loaders. */
             resolveLoader?: ResolveLoader;
+            /**
+             *  Specify dependencies that shouldn’t be resolved by webpack, but should become dependencies of the resulting bundle.
+             *  The kind of the dependency depends on output.libraryTarget.
+             */
             externals?: ExternalsElement|ExternalsElement[];
+            /**
+             * <ul>
+             *   <li>"web" Compile for usage in a browser-like environment (default)</li>
+             *   <li>"webworker" Compile as WebWorker</li>
+             *   <li>"node" Compile for usage in a node.js-like environment (use require to load chunks)</li>
+             *   <li>"async-node" Compile for usage in a node.js-like environment (use fs and vm to load chunks async)</li>
+             *   <li>"node-webkit" Compile for usage in webkit, uses jsonp chunk loading but also supports builtin node.js modules plus require(“nw.gui”) (experimental)</li>
+             *   <li>"atom" Compile for usage in electron (formerly known as atom-shell), supports require for modules necessary to run Electron.</li>
+             * <ul>
+             */
             target?: string;
+            /** Report the first error as a hard error instead of tolerating it. */
             bail?: boolean;
+            /** Capture timing information for each module. */
             profile?: boolean;
+            /** Cache generated modules and chunks to improve performance for multiple incremental builds. */
             cache?: boolean|any;
+            /** Enter watch mode, which rebuilds on file change. */
             watch?: boolean;
             watchOptions?: WatchOptions;
+            /** Switch loaders to debug mode. */
             debug?: boolean;
+            /** Can be used to configure the behaviour of webpack-dev-server when the webpack config is passed to webpack-dev-server CLI. */
             devServer?: any; // TODO: Type this
+            /** Include polyfills or mocks for various node stuff */
             node?: Node;
+            /** Set the value of require.amd and define.amd. */
             amd?: { [moduleName: string]: boolean };
+            /** Used for recordsInputPath and recordsOutputPath */
             recordsPath?: string;
+            /** Load compiler state from a json file. */
             recordsInputPath?: string;
+            /** Store compiler state to a json file. */
             recordsOutputPath?: string;
+            /** Add additional plugins to the compiler. */
             plugins?: (Plugin|Function)[];
         }
 
@@ -35,30 +66,67 @@ declare module "webpack" {
         }
 
         interface Output {
+            /** The output directory as absolute path (required). */
             path?: string;
+            /** The filename of the entry chunk as relative path inside the output.path directory. */
             filename?: string;
+            /** The filename of non-entry chunks as relative path inside the output.path directory. */
             chunkFilename?: string;
+            /** The filename of the SourceMaps for the JavaScript files. They are inside the output.path directory. */
             sourceMapFilename?: string;
+            /** Filename template string of function for the sources array in a generated SourceMap. */
             devtoolModuleFilenameTemplate?: string;
+            /** Similar to output.devtoolModuleFilenameTemplate, but used in the case of duplicate module identifiers. */
             devtoolFallbackModuleFilenameTemplate?: string;
+            /**
+             * Enable line to line mapped mode for all/specified modules.
+             * Line to line mapped mode uses a simple SourceMap where each line of the generated source is mapped to the same line of the original source.
+             * It’s a performance optimization. Only use it if your performance need to be better and you are sure that input lines match which generated lines.
+             * true enables it for all modules (not recommended)
+             */
             devtoolLineToLine?: boolean;
+            /** The filename of the Hot Update Chunks. They are inside the output.path directory. */
             hotUpdateChunkFilename?: string;
+            /** The filename of the Hot Update Main File. It is inside the output.path directory. */
             hotUpdateMainFilename?: string;
+            /** The output.path from the view of the Javascript / HTML page. */
             publicPath?: string;
+            /** The JSONP function used by webpack for asnyc loading of chunks. */
             jsonpFunction?: string;
+            /** The JSONP function used by webpack for async loading of hot update chunks. */
             hotUpdateFunction?: string;
+            /** Include comments with information about the modules. */
             pathinfo?: boolean;
+            /** If set, export the bundle as library. output.library is the name. */
             library?: boolean;
+            /**
+             * Which format to export the library:
+             * <ul>
+             *   <li>"var" - Export by setting a variable: var Library = xxx (default)</li>
+             *   <li>"this" - Export by setting a property of this: this["Library"] = xxx</li>
+             *   <li>"commonjs" - Export by setting a property of exports: exports["Library"] = xxx</li>
+             *   <li>"commonjs2" - Export by setting module.exports: module.exports = xxx</li>
+             *   <li>"amd" - Export to AMD (optionally named)</li>
+             *   <li>"umd" - Export to AMD, CommonJS2 or as property in root</li>
+             * </ul>
+             */
             libraryTarget?: string;
+            /** If output.libraryTarget is set to umd and output.library is set, setting this to true will name the AMD module. */
             umdNamedDefine?: boolean;
+            /** Prefixes every line of the source in the bundle with this string. */
             sourcePrefix?: string;
+            /** This option enables cross-origin loading of chunks. */
             crossOriginLoading?: string|boolean;
         }
 
         interface Module {
+            /** A array of automatically applied loaders. */
             loaders?: Loader[];
+            /** A array of applied pre loaders. */
             preLoaders?: Loader[];
+            /** A array of applied post loaders. */
             postLoaders?: Loader[];
+            /** A RegExp or an array of RegExps. Don’t parse files matching. */
             noParse?: RegExp|RegExp[];
             unknownContextRequest?: string;
             unknownContextRecursive?: boolean;
@@ -74,17 +142,43 @@ declare module "webpack" {
         }
 
         interface Resolve {
+            /** Replace modules by other modules or paths. */
             alias: { [key: string]: string; };
+            /**
+             * The directory (absolute path) that contains your modules.
+             * May also be an array of directories.
+             * This setting should be used to add individual directories to the search path. */
             root?: string|string[];
+            /**
+             * An array of directory names to be resolved to the current directory as well as its ancestors, and searched for modules.
+             * This functions similarly to how node finds “node_modules” directories.
+             * For example, if the value is ["mydir"], webpack will look in “./mydir”, “../mydir”, “../../mydir”, etc.
+             */
             modulesDirectories?: string[];
+            /**
+             * A directory (or array of directories absolute paths),
+             * in which webpack should look for modules that weren’t found in resolve.root or resolve.modulesDirectories.
+             */
             fallback?: string|string[];
+            /**
+             * An array of extensions that should be used to resolve modules.
+             * For example, in order to discover CoffeeScript files, your array should contain the string ".coffee".
+             */
             extensions?: string[];
+            /** Check these fields in the package.json for suitable files. */
             packageMains?: (string|string[])[];
+            /** Check this field in the package.json for an object. Key-value-pairs are threaded as aliasing according to this spec */
             packageAlias?: (string|string[])[];
+            /**
+             * Enable aggressive but unsafe caching for the resolving of a part of your files.
+             * Changes to cached paths may cause failure (in rare cases). An array of RegExps, only a RegExp or true (all files) is expected.
+             * If the resolved path matches, it’ll be cached.
+             */
             unsafeCache?: RegExp|RegExp[]|boolean;
         }
 
         interface ResolveLoader extends Resolve {
+            /** It describes alternatives for the module name that are tried. */
             moduleTemplates?: string[];
         }
 
@@ -99,7 +193,9 @@ declare module "webpack" {
         }
 
         interface WatchOptions {
+            /** Delay the rebuilt after the first change. Value is a time in ms. */
             aggregateTimeout?: number;
+            /** true: use polling, number: use polling with specified interval */
             poll?: boolean|number;
         }
 
@@ -116,10 +212,15 @@ declare module "webpack" {
         type LoaderCondition = string|RegExp|((absPath: string) => boolean);
 
         interface Loader {
+            /** A condition that must not be met */
             exclude?: LoaderCondition|LoaderCondition[];
+            /** A condition that must be met */
             include?: LoaderCondition|LoaderCondition[];
+            /** A condition that must be met */
             test: LoaderCondition|LoaderCondition[];
+            /** A string of “!” separated loaders */
             loader?: string;
+            /** A array of loaders as string */
             loaders?: string[];
             query?: {
                 [name: string]: any;