// Generated by dts-bundle v0.7.3

export = wdm;
/**
    * @template {IncomingMessage} Request
    * @template {ServerResponse} Response
    * @param {Compiler | MultiCompiler} compiler
    * @param {Options<Request, Response>} [options]
    * @returns {API<Request, Response>}
    */
function wdm<
    Request_1 extends import("http").IncomingMessage,
    Response_1 extends ServerResponse
>(
    compiler: Compiler | MultiCompiler,
    options?: Options<Request_1, Response_1> | undefined
): API<Request_1, Response_1>;
namespace wdm {
    export {
        Schema,
        Compiler,
        MultiCompiler,
        Configuration,
        Stats,
        MultiStats,
        ExtendedServerResponse,
        IncomingMessage,
        ServerResponse,
        NextFunction,
        WatchOptions,
        Watching,
        MultiWatching,
        OutputFileSystem,
        Logger,
        Callback,
        Context,
        Headers,
        Options,
        Middleware,
        GetFilenameFromUrl,
        WaitUntilValid,
        Invalidate,
        Close,
        AdditionalMethods,
        API,
    };
}
type ServerResponse = import("http").ServerResponse & ExtendedServerResponse;
type Compiler = import("webpack").Compiler;
type MultiCompiler = import("webpack").MultiCompiler;
type Options<
    Request_1 extends import("http").IncomingMessage,
    Response_1 extends ServerResponse
> = {
    mimeTypes?:
        | {
                [key: string]: string;
            }
        | undefined;
    writeToDisk?: boolean | ((targetPath: string) => boolean) | undefined;
    methods?: string | undefined;
    headers?: Headers<Request_1, Response_1>;
    publicPath?: NonNullable<Configuration["output"]>["publicPath"];
    stats?: Configuration["stats"];
    serverSideRender?: boolean | undefined;
    outputFileSystem?: OutputFileSystem | undefined;
    index?: string | boolean | undefined;
};
type API<
    Request_1 extends import("http").IncomingMessage,
    Response_1 extends ServerResponse
> = Middleware<Request_1, Response_1> &
    AdditionalMethods<Request_1, Response_1>;
type Schema = import("schema-utils/declarations/validate").Schema;
type Configuration = import("webpack").Configuration;
type Stats = import("webpack").Stats;
type MultiStats = import("webpack").MultiStats;
type ExtendedServerResponse = {
    locals?:
        | {
                webpack?:
                    | {
                            devMiddleware?:
                                | Context<import("http").IncomingMessage, ServerResponse>
                                | undefined;
                        }
                    | undefined;
            }
        | undefined;
};
type IncomingMessage = import("http").IncomingMessage;
type NextFunction = (err?: any) => void;
type WatchOptions = NonNullable<Configuration["watchOptions"]>;
type Watching = Compiler["watching"];
type MultiWatching = ReturnType<Compiler["watch"]>;
type OutputFileSystem = Compiler["outputFileSystem"] & {
    createReadStream?: typeof import("fs").createReadStream;
    statSync?: typeof import("fs").statSync;
    lstat?: typeof import("fs").lstat;
    readFileSync?: typeof import("fs").readFileSync;
};
type Logger = ReturnType<Compiler["getInfrastructureLogger"]>;
type Callback = (
    stats?: import("webpack").Stats | import("webpack").MultiStats | undefined
) => any;
type Context<
    Request_1 extends import("http").IncomingMessage,
    Response_1 extends ServerResponse
> = {
    state: boolean;
    stats: Stats | MultiStats | undefined;
    callbacks: Callback[];
    options: Options<Request_1, Response_1>;
    compiler: Compiler | MultiCompiler;
    watching: Watching | MultiWatching;
    logger: Logger;
    outputFileSystem: OutputFileSystem;
};
type Headers<
    Request_1 extends import("http").IncomingMessage,
    Response_1 extends ServerResponse
> =
    | Record<string, string | number>
    | {
            key: string;
            value: number | string;
        }[]
    | ((
            req: Request_1,
            res: Response_1,
            context: Context<Request_1, Response_1>
        ) => void | undefined | Record<string, string | number>)
    | undefined;
type Middleware<
    Request_1 extends import("http").IncomingMessage,
    Response_1 extends ServerResponse
> = (req: Request_1, res: Response_1, next: NextFunction) => Promise<void>;
type GetFilenameFromUrl = (url: string) => string | undefined;
type WaitUntilValid = (callback: Callback) => any;
type Invalidate = (callback: Callback) => any;
type Close = (callback: (err: Error | null | undefined) => void) => any;
type AdditionalMethods<
    Request_1 extends import("http").IncomingMessage,
    Response_1 extends ServerResponse
> = {
    getFilenameFromUrl: GetFilenameFromUrl;
    waitUntilValid: WaitUntilValid;
    invalidate: Invalidate;
    close: Close;
    context: Context<Request_1, Response_1>;
};