@rspack/dev-server 2.0.2 → 2.0.3

package/dist/index.d.ts

@@ -0,0 +1,1008 @@
+/// <reference types="node" />
+
+import { Agent } from 'http';
+import { API } from '@rspack/dev-middleware';
+import { Callback } from '@rspack/dev-middleware';
+import { ClientRequest } from 'http';
+import { ClientRequestArgs } from 'http';
+import { Compiler } from '@rspack/core';
+import { DevServer as Configuration } from '@rspack/core';
+import { Context } from '@rspack/dev-middleware';
+import { createConnection } from 'net';
+import type { DevServerClient } from '@rspack/core';
+import type { DevServerHeaders } from '@rspack/core';
+import type { DevServerHost } from '@rspack/core';
+import type { DevServerMiddlewareHandler } from '@rspack/core';
+import type { DevServerOpenOptions } from '@rspack/core';
+import type { DevServerProxyConfigArray } from '@rspack/core';
+import type { DevServerStatic } from '@rspack/core';
+import type { Dirent } from 'node:fs';
+import { Duplex } from 'stream';
+import { EventEmitter } from 'node:events';
+import { EventEmitter as EventEmitter_2 } from 'events';
+import * as http from 'node:http';
+import type { IncomingMessage as IncomingMessage_2 } from 'node:http';
+import { IncomingMessage as IncomingMessage_3 } from 'http';
+import type { ListenOptions } from 'node:net';
+import { MultiCompiler } from '@rspack/core';
+import { MultiStats } from '@rspack/core';
+import { Options } from '@rspack/dev-middleware';
+import { OutgoingHttpHeaders } from 'http';
+import { Readable } from 'node:stream';
+import { SecureContextOptions } from 'tls';
+import { Server as Server_2 } from 'node:net';
+import { Server as Server_3 } from 'node:tls';
+import type { Server as Server_4 } from 'node:http';
+import { Server as Server_6 } from 'http';
+import { Server as Server_7 } from 'https';
+import type { ServerOptions } from 'node:https';
+import type { ServerResponse } from 'node:http';
+import { Socket } from 'node:net';
+import { Stats } from 'node:fs';
+import { Stats as Stats_2 } from '@rspack/core';
+import { StatsOptions } from '@rspack/core';
+import { URL as URL_2 } from 'url';
+import type { WatchEventType } from 'node:fs';
+import { ZlibOptions } from 'zlib';
+
+declare type AWF = {
+    stabilityThreshold: number;
+    pollInterval: number;
+};
+
+declare type BasicApplication = {
+    use: UseFn;
+};
+
+declare type BasicOpts = {
+    persistent: boolean;
+    ignoreInitial: boolean;
+    followSymlinks: boolean;
+    cwd?: string;
+    usePolling: boolean;
+    interval: number;
+    binaryInterval: number;
+    alwaysStat?: boolean;
+    depth?: number;
+    ignorePermissionErrors: boolean;
+    atomic: boolean | number;
+};
+
+declare type BasicServer = Server_2 | Server_3;
+
+declare type BufferLike =
+| string
+| Buffer
+| DataView
+| number
+| ArrayBufferView
+| Uint8Array
+| ArrayBuffer
+| SharedArrayBuffer
+| Blob
+| readonly any[]
+| readonly number[]
+| { valueOf(): ArrayBuffer }
+| { valueOf(): SharedArrayBuffer }
+| { valueOf(): Uint8Array }
+| { valueOf(): readonly number[] }
+| { valueOf(): string }
+| { [Symbol.toPrimitive](hint: string): string };
+
+declare type ChokidarOptions = Partial<BasicOpts & {
+    ignored: Matcher | Matcher[];
+    awaitWriteFinish: boolean | Partial<AWF>;
+}>;
+
+declare type ClientConnection = WebSocket_2 & {
+    isAlive?: boolean;
+};
+
+export { Configuration }
+
+declare interface Configuration_2<A extends BasicApplication = Server, S extends BasicServer = Server_4> {
+    ipc?: boolean | string;
+    host?: DevServerHost;
+    port?: Port;
+    hot?: boolean | 'only';
+    liveReload?: boolean;
+    devMiddleware?: DevMiddlewareOptions<Request_2, Response_2>;
+    compress?: boolean;
+    allowedHosts?: LiteralUnion<'auto' | 'all', string> | string[];
+    historyApiFallback?: boolean | ConnectHistoryApiFallbackOptions;
+    watchFiles?: string | string[] | WatchFiles | Array<string | WatchFiles>;
+    static?: DevServerStatic;
+    server?: ServerType<A, S> | ServerConfiguration<A, S>;
+    app?: () => Promise<A>;
+    webSocketServer?: boolean | LiteralUnion<'ws', string> | WebSocketServerConfiguration;
+    proxy?: DevServerProxyConfigArray;
+    open?: boolean | string | Open | Array<string | Open>;
+    setupExitSignals?: boolean;
+    client?: boolean | DevServerClient;
+    headers?: DevServerHeaders | ((req: Request_2, res: Response_2, context: DevMiddlewareContext<Request_2, Response_2> | undefined) => DevServerHeaders);
+    onListening?: (devServer: RspackDevServer<A, S>) => void;
+    setupMiddlewares?: (middlewares: Middleware[], devServer: RspackDevServer<A, S>) => Middleware[];
+}
+
+declare type ConnectHistoryApiFallbackOptions = Exclude<NonNullable<Configuration['historyApiFallback']>, boolean>;
+
+declare type DevMiddlewareContext<T extends Request_2, U extends Response_2> = Context<T, U>;
+
+declare type DevMiddlewareOptions<T extends Request_2, U extends Response_2> = Options<T, U>;
+
+/** Directory entry. Contains path, depth count, and files. */
+declare interface DirEntry {
+    files: PathOrDirent[];
+    depth: number;
+    path: Path_2;
+}
+
+/**
+ * Directory entry.
+ */
+declare class DirEntry_2 {
+    path: Path;
+    _removeWatcher: (dir: string, base: string) => void;
+    items: Set<Path>;
+    constructor(dir: Path, removeWatcher: (dir: string, base: string) => void);
+    add(item: string): void;
+    remove(item: string): Promise<void>;
+    has(item: string): boolean | undefined;
+    getChildren(): string[];
+    dispose(): void;
+}
+
+declare type EmitArgs = [path: Path, stats?: Stats];
+
+declare type EmitArgsWithName = [event: EventName, ...EmitArgs];
+
+/** Emitted entry. Contains relative & absolute path, basename, and either stats or dirent. */
+declare interface EntryInfo {
+    path: string;
+    fullPath: string;
+    stats?: Stats;
+    dirent?: Dirent;
+    basename: string;
+}
+
+declare type EntryType = (typeof EntryTypes)[keyof typeof EntryTypes];
+
+declare const EntryTypes: {
+    readonly FILE_TYPE: "files";
+    readonly DIR_TYPE: "directories";
+    readonly FILE_DIR_TYPE: "files_directories";
+    readonly EVERYTHING_TYPE: "all";
+};
+
+declare type ErrorHandleFunction = (err: any, req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
+
+declare type EventName = (typeof EVENTS)[keyof typeof EVENTS];
+
+declare const EVENTS: {
+    readonly ALL: "all";
+    readonly READY: "ready";
+    readonly ADD: "add";
+    readonly CHANGE: "change";
+    readonly ADD_DIR: "addDir";
+    readonly UNLINK: "unlink";
+    readonly UNLINK_DIR: "unlinkDir";
+    readonly RAW: "raw";
+    readonly ERROR: "error";
+};
+
+declare type EXPECTED_ANY = any;
+
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ *     new FSWatcher()
+ *       .add(directories)
+ *       .on('add', path => log('File', path, 'was added'))
+ */
+declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
+    closed: boolean;
+    options: FSWInstanceOptions;
+    _closers: Map<string, Array<any>>;
+    _ignoredPaths: Set<Matcher>;
+    _throttled: Map<ThrottleType, Map<any, any>>;
+    _streams: Set<ReaddirpStream>;
+    _symlinkPaths: Map<Path, string | boolean>;
+    _watched: Map<string, DirEntry_2>;
+    _pendingWrites: Map<string, any>;
+    _pendingUnlinks: Map<string, EmitArgsWithName>;
+    _readyCount: number;
+    _emitReady: () => void;
+    _closePromise?: Promise<void>;
+    _userIgnored?: MatchFunction;
+    _readyEmitted: boolean;
+    _emitRaw: WatchHandlers['rawEmitter'];
+    _boundRemove: (dir: string, item: string) => void;
+    _nodeFsHandler: NodeFsHandler;
+    constructor(_opts?: ChokidarOptions);
+    _addIgnoredPath(matcher: Matcher): void;
+    _removeIgnoredPath(matcher: Matcher): void;
+    /**
+     * Adds paths to be watched on an existing FSWatcher instance.
+     * @param paths_ file or file list. Other arguments are unused
+     */
+    add(paths_: Path | Path[], _origAdd?: string, _internal?: boolean): FSWatcher;
+    /**
+     * Close watchers or start ignoring events from specified paths.
+     */
+    unwatch(paths_: Path | Path[]): FSWatcher;
+    /**
+     * Close watchers and remove all listeners from watched paths.
+     */
+    close(): Promise<void>;
+    /**
+     * Expose list of watched paths
+     * @returns for chaining
+     */
+    getWatched(): Record<string, string[]>;
+    emitWithAll(event: EventName, args: EmitArgs): void;
+    /**
+     * Normalize and emit events.
+     * Calling _emit DOES NOT MEAN emit() would be called!
+     * @param event Type of event
+     * @param path File or directory path
+     * @param stats arguments to be passed with event
+     * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _emit(event: EventName, path: Path, stats?: Stats): Promise<this | undefined>;
+    /**
+     * Common handler for errors
+     * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _handleError(error: Error): Error | boolean;
+    /**
+     * Helper utility for throttling
+     * @param actionType type being throttled
+     * @param path being acted upon
+     * @param timeout duration of time to suppress duplicate actions
+     * @returns tracking object or false if action should be suppressed
+     */
+    _throttle(actionType: ThrottleType, path: Path, timeout: number): Throttler | false;
+    _incrReadyCount(): number;
+    /**
+     * Awaits write operation to finish.
+     * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+     * @param path being acted upon
+     * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+     * @param event
+     * @param awfEmit Callback to be called when ready for event to be emitted.
+     */
+    _awaitWriteFinish(path: Path, threshold: number, event: EventName, awfEmit: (err?: Error, stat?: Stats) => void): void;
+    /**
+     * Determines whether user has asked to ignore this path.
+     */
+    _isIgnored(path: Path, stats?: Stats): boolean;
+    _isntIgnored(path: Path, stat?: Stats): boolean;
+    /**
+     * Provides a set of common helpers and properties relating to symlink handling.
+     * @param path file or directory pattern being watched
+     */
+    _getWatchHelpers(path: Path): WatchHelper;
+    /**
+     * Provides directory tracking objects
+     * @param directory path of the directory
+     */
+    _getWatchedDir(directory: string): DirEntry_2;
+    /**
+     * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+     */
+    _hasReadPermissions(stats: Stats): boolean;
+    /**
+     * Handles emitting unlink events for
+     * files and directories, and via recursion, for
+     * files and directories within directories that are unlinked
+     * @param directory within which the following item is located
+     * @param item      base path of item/directory
+     */
+    _remove(directory: string, item: string, isDirectory?: boolean): void;
+    /**
+     * Closes all watchers for a path
+     */
+    _closePath(path: Path): void;
+    /**
+     * Closes only file-specific watchers
+     */
+    _closeFile(path: Path): void;
+    _addPathCloser(path: Path, closer: () => void): void;
+    _readdirp(root: Path, opts?: Partial<ReaddirpOptions>): ReaddirpStream | undefined;
+}
+
+declare interface FSWatcherEventMap {
+    [EVENTS.READY]: [];
+    [EVENTS.RAW]: Parameters<WatchHandlers['rawEmitter']>;
+    [EVENTS.ERROR]: Parameters<WatchHandlers['errHandler']>;
+    [EVENTS.ALL]: [event: EventName, ...EmitArgs];
+    [EVENTS.ADD]: EmitArgs;
+    [EVENTS.CHANGE]: EmitArgs;
+    [EVENTS.ADD_DIR]: EmitArgs;
+    [EVENTS.UNLINK]: EmitArgs;
+    [EVENTS.UNLINK_DIR]: EmitArgs;
+}
+
+declare type FSWInstanceOptions = BasicOpts & {
+    ignored: Matcher[];
+    awaitWriteFinish: false | AWF;
+};
+
+declare type HandleFunction = SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction;
+
+/**
+ * Public and internal Connect types.
+ */
+declare interface IncomingMessage extends http.IncomingMessage {
+    originalUrl?: http.IncomingMessage['url'] | undefined;
+}
+
+/** https://github.com/microsoft/TypeScript/issues/29729 */
+declare type LiteralUnion<T extends U, U> = T | (U & Record<never, never>);
+
+declare type Matcher = string | RegExp | MatchFunction | MatcherObject;
+
+declare interface MatcherObject {
+    path: string;
+    recursive?: boolean;
+}
+
+declare type MatchFunction = (val: string, stats?: Stats) => boolean;
+
+declare type Middleware = MiddlewareObject | DevServerMiddlewareHandler | ErrorHandleFunction;
+
+declare interface MiddlewareObject {
+    name?: string;
+    path?: string;
+    middleware: DevServerMiddlewareHandler | ErrorHandleFunction;
+}
+
+declare type NextFunction = (err?: any) => void;
+
+declare type NextHandleFunction = (req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
+
+/**
+ * @mixin
+ */
+declare class NodeFsHandler {
+    fsw: FSWatcher;
+    _boundHandleError: (error: unknown) => void;
+    constructor(fsW: FSWatcher);
+    /**
+     * Watch file for changes with fs_watchFile or fs_watch.
+     * @param path to file or dir
+     * @param listener on fs change
+     * @returns closer for the watcher instance
+     */
+    _watchWithNodeFs(path: string, listener: (path: string, newStats?: any) => void | Promise<void>): (() => void) | undefined;
+    /**
+     * Watch a file and emit add event if warranted.
+     * @returns closer for the watcher instance
+     */
+    _handleFile(file: Path, stats: Stats, initialAdd: boolean): (() => void) | undefined;
+    /**
+     * Handle symlinks encountered while reading a dir.
+     * @param entry returned by readdirp
+     * @param directory path of dir being read
+     * @param path of this item
+     * @param item basename of this item
+     * @returns true if no more processing is needed for this entry.
+     */
+    _handleSymlink(entry: EntryInfo, directory: string, path: Path, item: string): Promise<boolean | undefined>;
+    _handleRead(directory: string, initialAdd: boolean, wh: WatchHelper, target: Path | undefined, dir: Path, depth: number, throttler: Throttler): Promise<unknown> | undefined;
+    /**
+     * Read directory to add / remove files from `@watched` list and re-read it on change.
+     * @param dir fs path
+     * @param stats
+     * @param initialAdd
+     * @param depth relative to user-supplied path
+     * @param target child path targeted for watch
+     * @param wh Common watch helpers for this path
+     * @param realpath
+     * @returns closer for the watcher instance.
+     */
+    _handleDir(dir: string, stats: Stats, initialAdd: boolean, depth: number, target: string | undefined, wh: WatchHelper, realpath: string): Promise<(() => void) | undefined>;
+    /**
+     * Handle added file, directory, or glob pattern.
+     * Delegates call to _handleFile / _handleDir after checks.
+     * @param path to file or ir
+     * @param initialAdd was the file added at watch instantiation?
+     * @param priorWh depth relative to user-supplied path
+     * @param depth Child path actually targeted for watch
+     * @param target Child path actually targeted for watch
+     */
+    _addToNodeFs(path: string, initialAdd: boolean, priorWh: WatchHelper | undefined, depth: number, target?: string): Promise<string | false | undefined>;
+}
+
+declare type Open = DevServerOpenOptions & {
+    target?: string | string[];
+};
+
+declare type Path = string;
+
+/** Path in file system. */
+declare type Path_2 = string;
+
+/** Path or dir entries (files) */
+declare type PathOrDirent = Dirent | Path_2;
+
+declare type Port = number | LiteralUnion<'auto', string>;
+
+declare type Predicate = string[] | string | Tester;
+
+/**
+ * Options for readdirp.
+ * * type: files, directories, or both
+ * * lstat: whether to use symlink-friendly stat
+ * * depth: max depth
+ * * alwaysStat: whether to use stat (more resources) or dirent
+ * * highWaterMark: streaming param, specifies max amount of resources per entry
+ */
+declare type ReaddirpOptions = {
+    root: string;
+    fileFilter?: Predicate;
+    directoryFilter?: Predicate;
+    type?: EntryType;
+    lstat?: boolean;
+    depth?: number;
+    alwaysStat?: boolean;
+    highWaterMark?: number;
+};
+
+/** Readable readdir stream, emitting new files as they're being listed. */
+declare class ReaddirpStream extends Readable {
+    parents: any[];
+    reading: boolean;
+    parent?: DirEntry;
+    _stat: Function;
+    _maxDepth: number;
+    _wantsDir: boolean;
+    _wantsFile: boolean;
+    _wantsEverything: boolean;
+    _root: Path_2;
+    _isDirent: boolean;
+    _statsProp: 'dirent' | 'stats';
+    _rdOptions: {
+        encoding: 'utf8';
+        withFileTypes: boolean;
+    };
+    _fileFilter: Tester;
+    _directoryFilter: Tester;
+    constructor(options?: Partial<ReaddirpOptions>);
+    _read(batch: number): Promise<void>;
+    _exploreDir(path: Path_2, depth: number): Promise<{
+        files: string[] | undefined;
+        depth: number;
+        path: string;
+    }>;
+    _formatEntry(dirent: PathOrDirent, path: Path_2): Promise<EntryInfo | undefined>;
+    _onError(err: Error): void;
+    _getEntryType(entry: EntryInfo): Promise<void | '' | 'file' | 'directory'>;
+    _includeAsFile(entry: EntryInfo): boolean | undefined;
+}
+
+declare type Request_2<T extends BasicApplication = Server> = T extends Server ? IncomingMessage : IncomingMessage_2;
+
+declare type Response_2 = ServerResponse;
+
+export declare class RspackDevServer<A extends BasicApplication = Server, S extends BasicServer = Server_4> {
+    #private;
+    compiler: Compiler | MultiCompiler;
+    logger: ReturnType<Compiler['getInfrastructureLogger']>;
+    options: Configuration_2<A, S>;
+    staticWatchers: FSWatcher[];
+    listeners: {
+        name: string | symbol;
+        listener: (...args: EXPECTED_ANY[]) => void;
+    }[];
+    webSocketProxies: NextHandleFunction[];
+    sockets: Socket[];
+    currentHash: string | undefined;
+    isTlsServer: boolean;
+    webSocketServer: WebSocketServerImplementation | null | undefined;
+    middleware: API<Request_2, Response_2> | undefined;
+    server: S | undefined;
+    app: A | undefined;
+    stats: Stats_2 | MultiStats | undefined;
+    constructor(options: Configuration, compiler: Compiler | MultiCompiler);
+    static get DEFAULT_STATS(): StatsOptions;
+    static isAbsoluteURL(URL: string): boolean;
+    static findIp(gatewayOrFamily: string, isInternal: boolean): string | undefined;
+    static getHostname(hostname: DevServerHost): Promise<string>;
+    static getFreePort(port: string, host: string): Promise<string | number>;
+    static findCacheDir(): string;
+    getClientEntry(): string;
+    getClientHotEntry(): string | undefined;
+    isValidHost(headers: Record<string, string | undefined>, headerToCheck: string, validateHost?: boolean): boolean;
+    sendMessage(clients: ClientConnection[], type: string, data?: EXPECTED_ANY, params?: EXPECTED_ANY): void;
+    watchFiles(watchPath: string | string[], watchOptions?: ChokidarOptions): Promise<void>;
+    invalidate(callback?: Callback): void;
+    start(): Promise<void>;
+    startCallback(callback?: (err?: Error) => void): void;
+    stop(): Promise<void>;
+    stopCallback(callback?: (err?: Error) => void): void;
+}
+
+declare interface Server extends EventEmitter {
+    (req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void;
+    route: string;
+    stack: ServerStackItem[];
+    handle(req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void;
+    use(fn: NextHandleFunction): Server;
+    use(fn: HandleFunction): Server;
+    use(fn: http.Server): Server;
+    use(route: string, fn: NextHandleFunction): Server;
+    use(route: string, fn: HandleFunction): Server;
+    use(route: string, fn: http.Server): Server;
+    listen(port: number, hostname?: string, backlog?: number, callback?: Function): http.Server;
+    listen(port: number, hostname?: string, callback?: Function): http.Server;
+    listen(path: string, callback?: Function): http.Server;
+    listen(options: ListenOptions, callback?: Function): http.Server;
+    listen(handle: unknown, listeningListener?: Function): http.Server;
+}
+
+declare class Server_5<
+T extends typeof WebSocket_2 = typeof WebSocket_2,
+U extends typeof IncomingMessage_3 = typeof IncomingMessage_3,
+> extends EventEmitter_2 {
+    options: WebSocket_2.ServerOptions<T, U>;
+    path: string;
+    clients: Set<InstanceType<T>>;
+
+    constructor(options?: WebSocket_2.ServerOptions<T, U>, callback?: () => void);
+
+    address(): WebSocket_2.AddressInfo | string | null;
+    close(cb?: (err?: Error) => void): void;
+    handleUpgrade(
+    request: InstanceType<U>,
+    socket: Duplex,
+    upgradeHead: Buffer,
+    callback: (client: InstanceType<T>, request: InstanceType<U>) => void,
+    ): void;
+    shouldHandle(request: InstanceType<U>): boolean | Promise<boolean>;
+
+    // Events
+    on(event: "connection", cb: (this: Server_5<T>, websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    on(event: "error", cb: (this: Server_5<T>, error: Error) => void): this;
+    on(event: "headers", cb: (this: Server_5<T>, headers: string[], request: InstanceType<U>) => void): this;
+    on(event: "close" | "listening", cb: (this: Server_5<T>) => void): this;
+    on(
+    event: "wsClientError",
+    cb: (this: Server_5<T>, error: Error, socket: Duplex, request: InstanceType<U>) => void,
+    ): this;
+    on(event: string | symbol, listener: (this: Server_5<T>, ...args: any[]) => void): this;
+
+    once(
+    event: "connection",
+    cb: (this: Server_5<T>, websocket: InstanceType<T>, request: InstanceType<U>) => void,
+    ): this;
+    once(event: "error", cb: (this: Server_5<T>, error: Error) => void): this;
+    once(event: "headers", cb: (this: Server_5<T>, headers: string[], request: InstanceType<U>) => void): this;
+    once(event: "close" | "listening", cb: (this: Server_5<T>) => void): this;
+    once(
+    event: "wsClientError",
+    cb: (this: Server_5<T>, error: Error, socket: Duplex, request: InstanceType<U>) => void,
+    ): this;
+    once(event: string | symbol, listener: (this: Server_5<T>, ...args: any[]) => void): this;
+
+    off(event: "connection", cb: (this: Server_5<T>, websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    off(event: "error", cb: (this: Server_5<T>, error: Error) => void): this;
+    off(event: "headers", cb: (this: Server_5<T>, headers: string[], request: InstanceType<U>) => void): this;
+    off(event: "close" | "listening", cb: (this: Server_5<T>) => void): this;
+    off(
+    event: "wsClientError",
+    cb: (this: Server_5<T>, error: Error, socket: Duplex, request: InstanceType<U>) => void,
+    ): this;
+    off(event: string | symbol, listener: (this: Server_5<T>, ...args: any[]) => void): this;
+
+    addListener(event: "connection", cb: (websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    addListener(event: "error", cb: (error: Error) => void): this;
+    addListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
+    addListener(event: "close" | "listening", cb: () => void): this;
+    addListener(event: "wsClientError", cb: (error: Error, socket: Duplex, request: InstanceType<U>) => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    removeListener(event: "connection", cb: (websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    removeListener(event: "error", cb: (error: Error) => void): this;
+    removeListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
+    removeListener(event: "close" | "listening", cb: () => void): this;
+    removeListener(event: "wsClientError", cb: (error: Error, socket: Duplex, request: InstanceType<U>) => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
+declare interface ServerConfiguration<A extends BasicApplication = Server, S extends BasicServer = Server_4> {
+    type?: ServerType<A, S>;
+    options?: ServerOptions;
+}
+
+declare type ServerHandle = HandleFunction | http.Server;
+
+declare interface ServerStackItem {
+    route: string;
+    handle: ServerHandle;
+}
+
+declare type ServerType<A extends BasicApplication, S extends BasicServer> = LiteralUnion<'http' | 'https' | 'http2', string> | ((serverOptions: ServerOptions, application: A) => S);
+
+declare type SimpleHandleFunction = (req: IncomingMessage, res: http.ServerResponse) => void;
+
+/** Filterer for files */
+declare type Tester = (entryInfo: EntryInfo) => boolean;
+
+declare type Throttler = {
+    timeoutObject: NodeJS.Timeout;
+    clear: () => void;
+    count: number;
+};
+
+declare type ThrottleType = 'readdir' | 'watch' | 'add' | 'remove' | 'change';
+
+declare type UseFn = {
+    (fn: NextHandleFunction): BasicApplication;
+    (fn: HandleFunction): BasicApplication;
+    (route: string, fn: NextHandleFunction): BasicApplication;
+    (route: string, fn: HandleFunction): BasicApplication;
+};
+
+declare interface WatchFiles {
+    paths: string | string[];
+    options?: ChokidarOptions & {
+        aggregateTimeout?: number;
+        poll?: number | boolean;
+    };
+}
+
+declare interface WatchHandlers {
+    listener: (path: string) => void;
+    errHandler: (err: unknown) => void;
+    rawEmitter: (ev: WatchEventType, path: string, opts: unknown) => void;
+}
+
+declare class WatchHelper {
+    fsw: FSWatcher;
+    path: string;
+    watchPath: string;
+    fullWatchPath: string;
+    dirParts: string[][];
+    followSymlinks: boolean;
+    statMethod: 'stat' | 'lstat';
+    constructor(path: string, follow: boolean, fsw: FSWatcher);
+    entryPath(entry: EntryInfo): Path;
+    filterPath(entry: EntryInfo): boolean;
+    filterDir(entry: EntryInfo): boolean;
+}
+
+declare class WebSocket_2 extends EventEmitter_2 {
+    /** The connection is not yet open. */
+    static readonly CONNECTING: 0;
+    /** The connection is open and ready to communicate. */
+    static readonly OPEN: 1;
+    /** The connection is in the process of closing. */
+    static readonly CLOSING: 2;
+    /** The connection is closed. */
+    static readonly CLOSED: 3;
+
+    binaryType: "nodebuffer" | "arraybuffer" | "fragments";
+    readonly bufferedAmount: number;
+    readonly extensions: string;
+    /** Indicates whether the websocket is paused */
+    readonly isPaused: boolean;
+    readonly protocol: string;
+    /** The current state of the connection */
+    readonly readyState:
+    | typeof WebSocket_2.CONNECTING
+    | typeof WebSocket_2.OPEN
+    | typeof WebSocket_2.CLOSING
+    | typeof WebSocket_2.CLOSED;
+    readonly url: string;
+
+    /** The connection is not yet open. */
+    readonly CONNECTING: 0;
+    /** The connection is open and ready to communicate. */
+    readonly OPEN: 1;
+    /** The connection is in the process of closing. */
+    readonly CLOSING: 2;
+    /** The connection is closed. */
+    readonly CLOSED: 3;
+
+    onopen: ((event: WebSocket_2.Event) => void) | null;
+    onerror: ((event: WebSocket_2.ErrorEvent) => void) | null;
+    onclose: ((event: WebSocket_2.CloseEvent) => void) | null;
+    onmessage: ((event: WebSocket_2.MessageEvent) => void) | null;
+
+    constructor(address: null);
+    constructor(address: string | URL_2, options?: WebSocket_2.ClientOptions | ClientRequestArgs);
+    constructor(
+    address: string | URL_2,
+    protocols?: string | string[],
+    options?: WebSocket_2.ClientOptions | ClientRequestArgs,
+    );
+
+    close(code?: number, data?: string | Buffer): void;
+    ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+    pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+    // https://github.com/websockets/ws/issues/2076#issuecomment-1250354722
+    send(data: BufferLike, cb?: (err?: Error) => void): void;
+    send(
+    data: BufferLike,
+    options: {
+        mask?: boolean | undefined;
+        binary?: boolean | undefined;
+        compress?: boolean | undefined;
+        fin?: boolean | undefined;
+    },
+    cb?: (err?: Error) => void,
+    ): void;
+    terminate(): void;
+
+    /**
+     * Pause the websocket causing it to stop emitting events. Some events can still be
+     * emitted after this is called, until all buffered data is consumed. This method
+     * is a noop if the ready state is `CONNECTING` or `CLOSED`.
+     */
+    pause(): void;
+    /**
+     * Make a paused socket resume emitting events. This method is a noop if the ready
+     * state is `CONNECTING` or `CLOSED`.
+     */
+    resume(): void;
+
+    // HTML5 WebSocket events
+    addEventListener<K extends keyof WebSocket_2.WebSocketEventMap>(
+    type: K,
+    listener:
+    | ((event: WebSocket_2.WebSocketEventMap[K]) => void)
+    | { handleEvent(event: WebSocket_2.WebSocketEventMap[K]): void },
+    options?: WebSocket_2.EventListenerOptions,
+    ): void;
+    removeEventListener<K extends keyof WebSocket_2.WebSocketEventMap>(
+    type: K,
+    listener:
+    | ((event: WebSocket_2.WebSocketEventMap[K]) => void)
+    | { handleEvent(event: WebSocket_2.WebSocketEventMap[K]): void },
+    ): void;
+
+    // Events
+    on(event: "close", listener: (this: WebSocket_2, code: number, reason: Buffer) => void): this;
+    on(event: "error", listener: (this: WebSocket_2, error: Error) => void): this;
+    on(event: "upgrade", listener: (this: WebSocket_2, request: IncomingMessage_3) => void): this;
+    on(event: "message", listener: (this: WebSocket_2, data: WebSocket_2.RawData, isBinary: boolean) => void): this;
+    on(event: "open", listener: (this: WebSocket_2) => void): this;
+    on(event: "ping" | "pong", listener: (this: WebSocket_2, data: Buffer) => void): this;
+    on(event: "redirect", listener: (this: WebSocket_2, url: string, request: ClientRequest) => void): this;
+    on(
+    event: "unexpected-response",
+    listener: (this: WebSocket_2, request: ClientRequest, response: IncomingMessage_3) => void,
+    ): this;
+    on(event: string | symbol, listener: (this: WebSocket_2, ...args: any[]) => void): this;
+
+    once(event: "close", listener: (this: WebSocket_2, code: number, reason: Buffer) => void): this;
+    once(event: "error", listener: (this: WebSocket_2, error: Error) => void): this;
+    once(event: "upgrade", listener: (this: WebSocket_2, request: IncomingMessage_3) => void): this;
+    once(event: "message", listener: (this: WebSocket_2, data: WebSocket_2.RawData, isBinary: boolean) => void): this;
+    once(event: "open", listener: (this: WebSocket_2) => void): this;
+    once(event: "ping" | "pong", listener: (this: WebSocket_2, data: Buffer) => void): this;
+    once(event: "redirect", listener: (this: WebSocket_2, url: string, request: ClientRequest) => void): this;
+    once(
+    event: "unexpected-response",
+    listener: (this: WebSocket_2, request: ClientRequest, response: IncomingMessage_3) => void,
+    ): this;
+    once(event: string | symbol, listener: (this: WebSocket_2, ...args: any[]) => void): this;
+
+    off(event: "close", listener: (this: WebSocket_2, code: number, reason: Buffer) => void): this;
+    off(event: "error", listener: (this: WebSocket_2, error: Error) => void): this;
+    off(event: "upgrade", listener: (this: WebSocket_2, request: IncomingMessage_3) => void): this;
+    off(event: "message", listener: (this: WebSocket_2, data: WebSocket_2.RawData, isBinary: boolean) => void): this;
+    off(event: "open", listener: (this: WebSocket_2) => void): this;
+    off(event: "ping" | "pong", listener: (this: WebSocket_2, data: Buffer) => void): this;
+    off(event: "redirect", listener: (this: WebSocket_2, url: string, request: ClientRequest) => void): this;
+    off(
+    event: "unexpected-response",
+    listener: (this: WebSocket_2, request: ClientRequest, response: IncomingMessage_3) => void,
+    ): this;
+    off(event: string | symbol, listener: (this: WebSocket_2, ...args: any[]) => void): this;
+
+    addListener(event: "close", listener: (code: number, reason: Buffer) => void): this;
+    addListener(event: "error", listener: (error: Error) => void): this;
+    addListener(event: "upgrade", listener: (request: IncomingMessage_3) => void): this;
+    addListener(event: "message", listener: (data: WebSocket_2.RawData, isBinary: boolean) => void): this;
+    addListener(event: "open", listener: () => void): this;
+    addListener(event: "ping" | "pong", listener: (data: Buffer) => void): this;
+    addListener(event: "redirect", listener: (url: string, request: ClientRequest) => void): this;
+    addListener(
+    event: "unexpected-response",
+    listener: (request: ClientRequest, response: IncomingMessage_3) => void,
+    ): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    removeListener(event: "close", listener: (code: number, reason: Buffer) => void): this;
+    removeListener(event: "error", listener: (error: Error) => void): this;
+    removeListener(event: "upgrade", listener: (request: IncomingMessage_3) => void): this;
+    removeListener(event: "message", listener: (data: WebSocket_2.RawData, isBinary: boolean) => void): this;
+    removeListener(event: "open", listener: () => void): this;
+    removeListener(event: "ping" | "pong", listener: (data: Buffer) => void): this;
+    removeListener(event: "redirect", listener: (url: string, request: ClientRequest) => void): this;
+    removeListener(
+    event: "unexpected-response",
+    listener: (request: ClientRequest, response: IncomingMessage_3) => void,
+    ): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
+declare namespace WebSocket_2 {
+    /**
+     * Data represents the raw message payload received over the WebSocket.
+     */
+    type RawData = Buffer | ArrayBuffer | Buffer[];
+
+    /**
+     * Data represents the message payload received over the WebSocket.
+     */
+    type Data = string | Buffer | ArrayBuffer | Buffer[];
+
+    /**
+     * CertMeta represents the accepted types for certificate & key data.
+     */
+    type CertMeta = string | string[] | Buffer | Buffer[];
+
+    /**
+     * VerifyClientCallbackSync is a synchronous callback used to inspect the
+     * incoming message. The return value (boolean) of the function determines
+     * whether or not to accept the handshake.
+     */
+    type VerifyClientCallbackSync<Request extends IncomingMessage_3 = IncomingMessage_3> = (info: {
+        origin: string;
+        secure: boolean;
+        req: Request;
+    }) => boolean;
+
+    /**
+     * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
+     * incoming message. The return value (boolean) of the function determines
+     * whether or not to accept the handshake.
+     */
+    type VerifyClientCallbackAsync<Request extends IncomingMessage_3 = IncomingMessage_3> = (
+    info: { origin: string; secure: boolean; req: Request },
+    callback: (res: boolean, code?: number, message?: string, headers?: OutgoingHttpHeaders) => void,
+    ) => void;
+
+    /**
+     * FinishRequestCallback is a callback for last minute customization of the
+     * headers. If finishRequest is set, then it has the responsibility to call
+     * request.end() once it is done setting request headers.
+     */
+    type FinishRequestCallback = (request: ClientRequest, websocket: WebSocket_2) => void;
+
+    interface ClientOptions extends SecureContextOptions {
+        protocol?: string | undefined;
+        followRedirects?: boolean | undefined;
+        generateMask?(mask: Buffer): void;
+        handshakeTimeout?: number | undefined;
+        maxRedirects?: number | undefined;
+        perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+        localAddress?: string | undefined;
+        protocolVersion?: number | undefined;
+        headers?: { [key: string]: string } | undefined;
+        origin?: string | undefined;
+        agent?: Agent | undefined;
+        host?: string | undefined;
+        family?: number | undefined;
+        checkServerIdentity?(servername: string, cert: CertMeta): boolean;
+        rejectUnauthorized?: boolean | undefined;
+        allowSynchronousEvents?: boolean | undefined;
+        autoPong?: boolean | undefined;
+        maxPayload?: number | undefined;
+        skipUTF8Validation?: boolean | undefined;
+        createConnection?: typeof createConnection | undefined;
+        finishRequest?: FinishRequestCallback | undefined;
+    }
+
+    interface PerMessageDeflateOptions {
+        serverNoContextTakeover?: boolean | undefined;
+        clientNoContextTakeover?: boolean | undefined;
+        serverMaxWindowBits?: number | undefined;
+        clientMaxWindowBits?: number | undefined;
+        zlibDeflateOptions?:
+        | {
+            flush?: number | undefined;
+            finishFlush?: number | undefined;
+            chunkSize?: number | undefined;
+            windowBits?: number | undefined;
+            level?: number | undefined;
+            memLevel?: number | undefined;
+            strategy?: number | undefined;
+            dictionary?: Buffer | Buffer[] | DataView | undefined;
+            info?: boolean | undefined;
+        }
+        | undefined;
+        zlibInflateOptions?: ZlibOptions | undefined;
+        threshold?: number | undefined;
+        concurrencyLimit?: number | undefined;
+    }
+
+    interface Event {
+        type: string;
+        target: WebSocket_2;
+    }
+
+    interface ErrorEvent {
+        error: any;
+        message: string;
+        type: string;
+        target: WebSocket_2;
+    }
+
+    interface CloseEvent {
+        wasClean: boolean;
+        code: number;
+        reason: string;
+        type: string;
+        target: WebSocket_2;
+    }
+
+    interface MessageEvent {
+        data: Data;
+        type: string;
+        target: WebSocket_2;
+    }
+
+    interface WebSocketEventMap {
+        open: Event;
+        error: ErrorEvent;
+        close: CloseEvent;
+        message: MessageEvent;
+    }
+
+    interface EventListenerOptions {
+        once?: boolean | undefined;
+    }
+
+    interface ServerOptions<
+    U extends typeof WebSocket_2 = typeof WebSocket_2,
+    V extends typeof IncomingMessage_3 = typeof IncomingMessage_3,
+    > {
+        host?: string | undefined;
+        port?: number | undefined;
+        backlog?: number | undefined;
+        server?: Server_6<V> | Server_7<V> | undefined;
+        verifyClient?:
+        | VerifyClientCallbackAsync<InstanceType<V>>
+        | VerifyClientCallbackSync<InstanceType<V>>
+        | undefined;
+        handleProtocols?: (protocols: Set<string>, request: InstanceType<V>) => string | false;
+        path?: string | undefined;
+        noServer?: boolean | undefined;
+        allowSynchronousEvents?: boolean | undefined;
+        autoPong?: boolean | undefined;
+        clientTracking?: boolean | undefined;
+        perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+        maxPayload?: number | undefined;
+        skipUTF8Validation?: boolean | undefined;
+        WebSocket?: U | undefined;
+    }
+
+    interface AddressInfo {
+        address: string;
+        family: string;
+        port: number;
+    }
+}
+
+declare type WebSocketServer = WebSocketServer_2;
+
+declare const WebSocketServer_2: typeof Server_5;
+
+declare interface WebSocketServer_2 extends Server_5 {}
+
+declare interface WebSocketServerConfiguration {
+    type?: LiteralUnion<'ws', string> | (() => WebSocketServerConfiguration);
+    options?: Record<string, EXPECTED_ANY>;
+}
+
+declare interface WebSocketServerImplementation {
+    implementation: WebSocketServer;
+    clients: ClientConnection[];
+}
+
+export { }