webpack-dev-middleware

hapiWrapper: <
    HapiServer,
    HapiOptionsInternal extends HapiOptions
>() => HapiPlugin<HapiServer, HapiOptionsInternal>;

koaWrapper: <
    RequestInternal extends any = any,
    ResponseInternal extends unknown = any
>(
    compiler: Compiler | MultiCompiler,
    options?: Options<RequestInternal, ResponseInternal> | undefined
) => (ctx: any, next: Function) => Promise<void> | void;

wdm: typeof wdm;

type AdditionalMethods<
    RequestInternal extends import('http').IncomingMessage,
    ResponseInternal extends ServerResponse
> = {
    getFilenameFromUrl: GetFilenameFromUrl;
    waitUntilValid: WaitUntilValid;
    invalidate: Invalidate;
    close: Close;
    context: Context<RequestInternal, ResponseInternal>;
};

type API<
    RequestInternal extends import('http').IncomingMessage = import('http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> = Middleware<RequestInternal, ResponseInternal> &
    AdditionalMethods<RequestInternal, ResponseInternal>;

type Callback = (
    stats?: import('webpack').Stats | import('webpack').MultiStats | undefined
) => any;

type Close = (callback: (err: Error | null | undefined) => void) => any;

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

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

type Context<
    RequestInternal extends import('http').IncomingMessage = import('http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> = {
    state: boolean;
    stats: Stats | MultiStats | undefined;
    callbacks: Callback[];
    options: Options<RequestInternal, ResponseInternal>;
    compiler: Compiler | MultiCompiler;
    watching: Watching | MultiWatching | undefined;
    logger: Logger;
    outputFileSystem: OutputFileSystem;
};

type ExtendedServerResponse = {
    locals?:
        | {
              webpack?:
                  | {
                        devMiddleware?:
                            | Context<import('http').IncomingMessage, ServerResponse>
                            | undefined;
                    }
                  | undefined;
          }
        | undefined;
};

type Extra = import('./utils/getFilenameFromUrl').Extra;

type FilledContext<
    RequestInternal extends import('http').IncomingMessage = import('http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> = WithoutUndefined<Context<RequestInternal, ResponseInternal>, 'watching'>;

type GetFilenameFromUrl = (
    url: string,
    extra?: Extra | undefined
) => string | undefined;

type HapiOptions = Options & {
    compiler: Compiler | MultiCompiler;
};

type HapiPlugin<S, O> = HapiPluginBase<S, O> & {
    pkg: {
        name: string;
    };
};

type HapiPluginBase<S, O> = {
    register: (server: S, options: O) => void | Promise<void>;
};

type Headers<
    RequestInternal extends import('http').IncomingMessage = import('http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> =
    | NormalizedHeaders
    | ((
          req: RequestInternal,
          res: ResponseInternal,
          context: Context<RequestInternal, ResponseInternal>
      ) => void | undefined | NormalizedHeaders)
    | undefined;

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

type Invalidate = (callback: Callback) => any;

type Logger = ReturnType<Compiler['getInfrastructureLogger']>;

type Middleware<
    RequestInternal extends import('http').IncomingMessage = import('http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> = (
    req: RequestInternal,
    res: ResponseInternal,
    next: NextFunction
) => Promise<void>;

type ModifyResponseData<
    RequestInternal extends import('http').IncomingMessage = import('http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> = (
    req: RequestInternal,
    res: ResponseInternal,
    data: Buffer | ReadStream,
    byteLength: number
) => ResponseData;

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

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

type MultiWatching = ReturnType<MultiCompiler['watch']>;

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

type NormalizedHeaders =
    | Record<string, string | number>
    | Array<{
          key: string;
          value: number | string;
      }>;

type Options<
    RequestInternal extends import('http').IncomingMessage = import('http').IncomingMessage,
    ResponseInternal extends ServerResponse = ServerResponse
> = {
    mimeTypes?:
        | {
              [key: string]: string;
          }
        | undefined;
    mimeTypeDefault?: string | undefined;
    writeToDisk?: boolean | ((targetPath: string) => boolean) | undefined;
    methods?: string[] | undefined;
    headers?: Headers<RequestInternal, ResponseInternal>;
    publicPath?: NonNullable<Configuration['output']>['publicPath'];
    stats?: Configuration['stats'];
    serverSideRender?: boolean | undefined;
    outputFileSystem?: OutputFileSystem | undefined;
    index?: string | boolean | undefined;
    modifyResponseData?:
        | ModifyResponseData<RequestInternal, ResponseInternal>
        | undefined;
    etag?: 'strong' | 'weak' | undefined;
    lastModified?: boolean | undefined;
};

type OutputFileSystem = Object & {
    createReadStream?: typeof import('fs').createReadStream;
    statSync?: import('fs').StatSyncFn;
    lstat?: typeof import('fs').lstat;
    readFileSync?: typeof import('fs').readFileSync;
};

type ReadStream = import('fs').ReadStream;

type ResponseData = {
    data: Buffer | ReadStream;
    byteLength: number;
};

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

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

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

type WaitUntilValid = (callback: Callback) => any;

type Watching = Compiler['watching'];

type WatchOptions = NonNullable<Configuration['watchOptions']>;

type WithOptional<T, K extends keyof T> = Omit<T, K> & Partial<T>;

type WithoutUndefined<T, K extends keyof T> = T & {
    [P in K]: NonNullable<T[P]>;
};