web-listener 0.1.0

package/index.d.ts

@@ -0,0 +1,1147 @@
+import { IncomingMessage, ServerResponse, RequestListener, Server, ServerOptions, OutgoingHttpHeaders, IncomingHttpHeaders, Agent } from 'node:http';
+import { Duplex, Readable, Writable } from 'node:stream';
+import { AddressInfo } from 'node:net';
+import { Stats } from 'node:fs';
+import { FileHandle } from 'node:fs/promises';
+import { ReadableStream, TextDecoderOptions, TransformStream } from 'node:stream/web';
+import { AgentOptions, Agent as Agent$1 } from 'node:https';
+
+type ClientErrorListener = (err: Error, socket: Duplex) => void;
+type UpgradeListener = (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
+type ShouldUpgradeCallback = (req: IncomingMessage) => boolean;
+
+interface Address {
+    type: 'IPv4' | 'IPv6' | 'alias';
+    ip: string;
+    port: number | undefined;
+}
+declare function parseAddress(address: string | undefined): Address | undefined;
+declare function makeAddressTester(cidrRanges: string[]): (address: Address | undefined) => boolean;
+
+declare class BlockingQueue<T> {
+    constructor();
+    push(value: T): void;
+    shift(timeout?: number | undefined): Promise<T>;
+    close(reason: unknown): void;
+    fail(reason: unknown): void;
+    [Symbol.asyncIterator](): AsyncIterator<T, unknown, undefined>;
+}
+
+declare function findCause<T>(error: unknown, errorType: {
+    new (...args: any[]): T;
+}): T | undefined;
+
+declare function getAddressURL(address: string | AddressInfo | null | undefined): string;
+
+declare class Queue<T> {
+    constructor(initialItem?: T);
+    isEmpty(): boolean;
+    clear(): void;
+    push(item: T): void;
+    shift(): T | null;
+    remove(item: T): void;
+    [Symbol.iterator](): Iterator<T, unknown, undefined>;
+}
+
+type UpgradeErrorHandler = (error: unknown, req: IncomingMessage, socket: Duplex) => void;
+type ServerGeneralErrorCallback = (error: unknown, action: string, req?: IncomingMessage) => void;
+type ServerErrorCallback = (error: unknown, action: string, req: IncomingMessage) => void;
+
+type MaybePromise<T> = Promise<T> | T;
+
+type SoftCloseHandler = (reason: string) => MaybePromise<void>;
+declare function setSoftCloseHandler(req: IncomingMessage, fn: SoftCloseHandler): void;
+declare const isSoftClosed: (req: IncomingMessage) => boolean;
+declare const defer: (req: IncomingMessage, fn: () => MaybePromise<void>) => void;
+declare const addTeardown: (req: IncomingMessage, fn: () => MaybePromise<void>) => void;
+declare const getAbortSignal: (req: IncomingMessage) => AbortSignal;
+
+type AcceptUpgradeHandler<T> = (...args: Parameters<UpgradeListener>) => Promise<AcceptUpgradeResult<T>>;
+interface AcceptUpgradeResult<T> {
+    return: T;
+    onError: UpgradeErrorHandler;
+    softCloseHandler: SoftCloseHandler;
+}
+declare function acceptUpgrade<T>(req: IncomingMessage, upgrade: AcceptUpgradeHandler<T>): Promise<T>;
+
+declare const PATH_PARAMETERS: unique symbol;
+type WithPathParameters<PathParameters> = {
+    [PATH_PARAMETERS]: PathParameters;
+};
+type WithoutPathParameters = {
+    [PATH_PARAMETERS]?: {
+        [k in PropertyKey]?: never;
+    };
+};
+declare function getPathParameters<PathParameters extends {}>(req: IncomingMessage & WithPathParameters<PathParameters>): Readonly<PathParameters>;
+declare const getPathParameter: <PathParameters extends {}, ID extends keyof PathParameters>(req: IncomingMessage & WithPathParameters<PathParameters>, id: ID) => Readonly<PathParameters>[ID];
+declare function getAbsolutePath(req: IncomingMessage): string;
+declare function restoreAbsolutePath(req: IncomingMessage): void;
+
+declare class RoutingInstruction extends Error {
+}
+declare const STOP: RoutingInstruction;
+declare const CONTINUE: RoutingInstruction;
+declare const NEXT_ROUTE: RoutingInstruction;
+declare const NEXT_ROUTER: RoutingInstruction;
+
+type ReturnHandlerParameter = object | null | undefined;
+type HandlerResult = void | null | undefined | typeof STOP | typeof CONTINUE | typeof NEXT_ROUTE | typeof NEXT_ROUTER | ReturnHandlerParameter;
+type RequestHandlerFn<Req = {}> = (req: IncomingMessage & Req, res: ServerResponse) => MaybePromise<HandlerResult>;
+interface RequestHandler<Req = {}> {
+    handleRequest: RequestHandlerFn<Req>;
+}
+declare const requestHandler: <Req>(handler: RequestHandler<Req> | RequestHandlerFn<Req>) => RequestHandler<Req>;
+type UpgradeHandlerFn<Req = {}> = (req: IncomingMessage & Req, socket: Duplex, head: Buffer) => MaybePromise<HandlerResult>;
+type ShouldUpgradeFn<Req = {}> = (req: IncomingMessage & Req) => boolean;
+interface UpgradeHandler<Req = {}> {
+    handleUpgrade: UpgradeHandlerFn<Req>;
+    shouldUpgrade?: ShouldUpgradeFn<Req> | undefined;
+}
+declare const upgradeHandler: <Req>(handler: UpgradeHandler<Req> | UpgradeHandlerFn<Req>, shouldUpgrade?: ShouldUpgradeFn<Req>) => UpgradeHandler<Req>;
+declare const anyHandler: <Req>(handler: UpgradeHandlerFn<Req> & RequestHandlerFn<Req>, shouldUpgrade?: ShouldUpgradeFn<Req>) => RequestHandler<Req> & UpgradeHandler<Req>;
+type ErrorHandlerFn<Req = {}> = (error: unknown, req: IncomingMessage & Req, output: {
+    response: ServerResponse;
+    socket?: never;
+    head?: never;
+} | {
+    response?: never;
+    socket: Duplex;
+    head: Buffer;
+}) => MaybePromise<HandlerResult>;
+interface ErrorHandler<Req = {}> {
+    handleError: ErrorHandlerFn<Req>;
+}
+declare const errorHandler: <Req>(handler: ErrorHandler<Req> | ErrorHandlerFn<Req>) => ErrorHandler<Req>;
+type Handler<Req = {}> = Partial<RequestHandler<Req> & UpgradeHandler<Req> & ErrorHandler<Req>>;
+type RequestReturnHandlerFn<Req = {}> = (value: ReturnHandlerParameter, req: IncomingMessage & Req, res: ServerResponse) => MaybePromise<void>;
+
+interface NativeListenersOptions {
+    onError?: ServerGeneralErrorCallback;
+    socketCloseTimeout?: number;
+}
+interface NativeListeners {
+    request: RequestListener;
+    upgrade: UpgradeListener;
+    shouldUpgrade: ShouldUpgradeCallback;
+    clientError: ClientErrorListener;
+    softClose(reason: string, onError: ServerErrorCallback, callback?: () => void): void;
+    hardClose(callback?: () => void): void;
+    countConnections(): number;
+}
+declare function toListeners(handler: Handler<WithoutPathParameters>, { onError, socketCloseTimeout }?: NativeListenersOptions): NativeListeners;
+
+interface TypedEventTargetInstance<This, Mapping> extends EventTarget {
+    addEventListener<K extends keyof Mapping>(type: K, listener: (this: This, event: Mapping[K], options?: AddEventListenerOptions | boolean) => void): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+}
+type TypedEventTarget<This, Mapping> = {
+    new (): TypedEventTargetInstance<This, Mapping>;
+};
+
+interface ListenOptions {
+    /**
+     * `backlog` parameter sent to `server.listen`.
+     *
+     * @default 511
+     */
+    backlog?: number | undefined;
+    /**
+     * If given, this is passed to `server.timeout`. The number of milliseconds of inactivity before a socket is presumed to have timed out.
+     */
+    socketTimeout?: number | undefined;
+}
+interface ListenerOptions extends Omit<NativeListenersOptions, 'onError'> {
+    /**
+     * Automatically send `417 Expectation Failed` for any request with a non-standard `Expect` header.
+     * Set to `false` to allow application-specific use of this header.
+     *
+     * @default true (matching Node.js behaviour)
+     */
+    rejectNonStandardExpect?: boolean | undefined;
+    /**
+     * Automatically send `100 Continue` for any request with `Expect: 100-continue`.
+     * If set to `false`, all handlers MUST call `acceptBody(req)` before attempting
+     * to read the body of the request (bundled body parsing middleware does this
+     * automatically).
+     *
+     * @default true (matching Node.js behaviour)
+     */
+    autoContinue?: boolean | undefined;
+    /**
+     * Override the shouldUpgradeCallback of the server with one that attempts to detect whether an
+     * upgrade request would be handled by the current routes. The detection does not invoke any
+     * handlers, but checks their `shouldUpgrade` function if it is present.
+     *
+     * @default true
+     */
+    overrideShouldUpgradeCallback?: boolean | undefined;
+}
+type CombinedServerOptions = ServerOptions & ListenOptions & ListenerOptions;
+declare const WebListener_base: TypedEventTarget<WebListener, {
+    error: CustomEvent<RequestErrorDetail>;
+}>;
+declare class WebListener extends WebListener_base {
+    constructor(handler: Handler<WithoutPathParameters>);
+    attach(server: Server, options?: ListenerOptions): (reason?: string, existingConnectionTimeout?: number, forceCloseAll?: boolean) => NativeListeners;
+    listen(port: number, host: string, options?: CombinedServerOptions): Promise<AugmentedServer>;
+}
+interface RequestErrorDetail {
+    error: unknown;
+    server: Server;
+    action: string;
+    request: IncomingMessage | undefined;
+}
+interface AugmentedServer extends Server {
+    closeWithTimeout(reason: string, timeout: number): Promise<void>;
+}
+
+type MessageBody = string | Buffer | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer;
+type AnyHeaders = HeadersInit | OutgoingHttpHeaders | Map<string, string | number | Readonly<string[]>> | undefined;
+interface HTTPErrorOptions {
+    message?: string;
+    statusMessage?: string;
+    headers?: AnyHeaders;
+    body?: MessageBody;
+    cause?: unknown;
+}
+interface PartialServerResponse {
+    setHeaders(headers: Headers): void;
+    setHeader(name: string, value: string): void;
+    writeHead(status: number, message: string, extraHeaders?: OutgoingHttpHeaders): void;
+    end(chunk: MessageBody, encoding: BufferEncoding): void;
+}
+declare class HTTPError extends Error {
+    readonly statusCode: number;
+    readonly statusMessage: string;
+    readonly headers: AnyHeaders;
+    readonly body: MessageBody;
+    constructor(statusCode: number, { message, statusMessage, headers, body, ...options }?: HTTPErrorOptions);
+    static readonly INTERNAL_SERVER_ERROR: HTTPError;
+    send(res: PartialServerResponse, extraHeaders?: OutgoingHttpHeaders): void;
+}
+
+type ParameterPrefixes = [':', '*'];
+type ParameterTerminators = ['/', '-', '.', ...ParameterPrefixes];
+interface ParameterTypes {
+    ':': string;
+    '*': string[];
+}
+type Resplit<S extends [string, string, string], D extends string> = S[0] extends `${infer A}${D}${infer B}` ? [A, D, `${B}${S[1]}${S[2]}`] : S;
+type ResplitRecur<S extends [string, string, string], Ds extends string[]> = Ds extends [
+    infer D extends string,
+    ...infer Rest extends string[]
+] ? Resplit<ResplitRecur<S, Rest>, D> : S;
+type SplitFirst<S extends string, Ds extends string[]> = ResplitRecur<[S, '', ''], Ds>;
+type ReadParam<D, R extends [string, string, string]> = R[1] extends keyof ParameterTypes ? never : {
+    [k in R[0]]: D extends keyof ParameterTypes ? ParameterTypes[D] : never;
+} & FindNextParam<SplitFirst<R[2], ParameterPrefixes>>;
+type FindNextParam<S extends [string, string, string]> = S[1] extends '' ? {} : ReadParam<S[1], SplitFirst<S[2], ParameterTerminators>>;
+type ReadParams<Path extends string> = FindNextParam<SplitFirst<Path, ParameterPrefixes>>;
+type ParametersFromPath<Path extends string> = Path extends `${infer Start}{${infer Optional}}${infer Rest}` ? ReadParams<Start> & Partial<ReadParams<Optional>> & ParametersFromPath<Rest> : ReadParams<Path>;
+
+declare const getSearch: (req: IncomingMessage) => string;
+declare const getSearchParams: (req: IncomingMessage) => URLSearchParams;
+declare const getQuery: (req: IncomingMessage, id: string) => string | null;
+
+type CommonMethod = 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
+type CommonUpgrade = 'http/2' | 'http/3' | 'https' | 'h2c' | 'websocket';
+type RelaxedRequestHandler<Req = {}> = RequestHandlerFn<Req> | RequestHandler<Req> | ErrorHandler<Req>;
+type RelaxedUpgradeHandler<Req = {}> = UpgradeHandlerFn<Req> | UpgradeHandler<Req> | ErrorHandler<Req>;
+type MethodWrapper<Req, This> = <Path extends string>(path: Path, ...handlers: RelaxedRequestHandler<Req & WithPathParameters<ParametersFromPath<Path>>>[]) => This;
+type UpgradeWrapper<Req, This> = <Path extends string>(path: Path, ...handlers: RelaxedUpgradeHandler<Req & WithPathParameters<ParametersFromPath<Path>>>[]) => This;
+declare class Router<Req = {}> implements Required<Handler<Req>> {
+    constructor();
+    /**
+     * Register handlers or routers for all requests, upgrades, and errors, on all methods and paths.
+     */
+    use(...handlers: Handler<Req>[]): this;
+    /**
+     * Register handlers or routers for all requests, upgrades, and errors, on all methods for all
+     * paths within the given path root.
+     *
+     * To register handlers at the path but not subpaths, use `.at` instead.
+     */
+    mount<Path extends string>(path: Path, ...handlers: Handler<Req & WithPathParameters<ParametersFromPath<Path>>>[]): this;
+    /**
+     * Create a new router mounted at the path, and call the given function to configure it.
+     */
+    within<Path extends string>(path: Path, init: (subRouter: Router<Req & WithPathParameters<ParametersFromPath<Path>>>) => void): this;
+    /**
+     * Register handlers or routers for all requests, upgrades, and errors, on all methods for a
+     * specific path.
+     *
+     * To register handlers at the path and all subpaths, use `.mount` instead.
+     */
+    at<Path extends string>(path: Path, ...handlers: Handler<Req & WithPathParameters<ParametersFromPath<Path>>>[]): this;
+    /**
+     * Register handlers for requests or errors (not upgrades) on a specific method for a specific
+     * path.
+     */
+    onRequest<Path extends string, Method extends string = CommonMethod>(method: Method | Iterable<Method>, path: Path, ...handlers: RelaxedRequestHandler<Req & WithPathParameters<ParametersFromPath<Path>>>[]): this;
+    /**
+     * Register handlers for upgrades or errors (not requests) on a specific method and protocol
+     * for a specific path.
+     */
+    onUpgrade<Path extends string, Method extends string = CommonMethod, Protocol extends string = CommonUpgrade>(method: Method | Iterable<Method> | null, protocol: Protocol, path: Path, ...handlers: RelaxedUpgradeHandler<Req & WithPathParameters<ParametersFromPath<Path>>>[]): this;
+    /**
+     * Register error handlers.
+     *
+     * Error handlers are called if a request or upgrade handler which is before them in the chain
+     * throws. Error handlers can send a response and return to complete processing of the request.
+     * Error handlers can also return `CONTINUE` (or any other routing instruction) to pass control
+     * back to request or upgrade handlers. If an error handler throws, a combined error
+     * (`SuppressedError`) will be sent to the next error handler.
+     */
+    onError(...handlers: (ErrorHandler<Req> | ErrorHandlerFn<Req>)[]): this;
+    /**
+     * Register return handlers.
+     *
+     * Return handlers are called if a request or error handler returns a value which is not a
+     * routing instruction. They can be used for features like templating or ensuring connections
+     * are always closed when a handler returns.
+     *
+     * Return hanlders are called in the order they were registered, and from the innermost router
+     * to the outermost rooter. Return handlers are not called for upgrade requests.
+     *
+     * Return handlers are not ordered with the other handlers, so they can be registered upfront if
+     * desired. If a return handler throws, the error will be passed to the next error handler after
+     * the request handler which triggered it.
+     */
+    onReturn(...handlers: RequestReturnHandlerFn<Req>[]): this;
+    /**
+     * Convenience wrapper for `.onRequest`, accepting paths with a HTTP verb at the start (separated
+     * by a space).
+     */
+    on<Path extends string>(path: `${CommonMethod} ${Path}`, ...handlers: RelaxedRequestHandler<Req & WithPathParameters<ParametersFromPath<Path>>>[]): this;
+    /**
+     * Registers handlers for GET requests at the given path. Note that these handlers will also
+     * be used for HEAD requests by default. To use different HEAD handling, you can register an
+     * explicit HEAD handler earlier in the router, or you can use `.getOnly` instead of `.get`.
+     *
+     * @param path
+     * @param handlers
+     * @returns
+     */
+    get: MethodWrapper<Req, this>;
+    /** Alias for `onRequest('DELETE', path, ...handlers)` */
+    delete: MethodWrapper<Req, this>;
+    /**
+     * Alias for `onRequest('GET', path, ...handlers)`
+     *
+     * Unlike `.get`, this will _not_ also use the handler for HEAD requests.
+     */
+    getOnly: MethodWrapper<Req, this>;
+    /** Alias for `onRequest('HEAD', path, ...handlers)` */
+    head: MethodWrapper<Req, this>;
+    /** Alias for `onRequest('OPTIONS', path, ...handlers)` */
+    options: MethodWrapper<Req, this>;
+    /** Alias for `onRequest('PATCH', path, ...handlers)` */
+    patch: MethodWrapper<Req, this>;
+    /** Alias for `onRequest('POST', path, ...handlers)` */
+    post: MethodWrapper<Req, this>;
+    /** Alias for `onRequest('PUT', path, ...handlers)` */
+    put: MethodWrapper<Req, this>;
+    /** Alias for `onUpgrade('GET', 'websocket', path, ...handlers)` */
+    ws: UpgradeWrapper<Req, this>;
+    /**
+     * Run routing on a request.
+     * The request must already be registered (i.e. have come through a WebListener).
+     *
+     * This can be used for complex custom sub-routing, but is otherwise not useful.
+     *
+     * To register an upgrade handler, use `.onRequest` or a convenience method.
+     */
+    handleRequest(req: IncomingMessage & Req): Promise<HandlerResult>;
+    /**
+     * Run routing on an upgrade request.
+     * The request must already be registered (i.e. have come through a WebListener).
+     *
+     * This can be used for complex custom sub-routing, but is otherwise not useful.
+     *
+     * To register an upgrade handler, use `.onUpgrade` or a convenience method.
+     */
+    handleUpgrade(req: IncomingMessage & Req): Promise<HandlerResult>;
+    /**
+     * Run routing on an error.
+     * The request must already be registered (i.e. have come through a WebListener).
+     *
+     * This can be used for complex custom sub-routing, but is otherwise not useful.
+     *
+     * To register an error handler, use `.onError`.
+     */
+    handleError(error: unknown, req: IncomingMessage & Req): Promise<HandlerResult>;
+    shouldUpgrade(req: IncomingMessage & Req): boolean;
+}
+
+interface BearerAuthOptions<Req, Token> {
+    realm: string | ((req: IncomingMessage & Req) => MaybePromise<string>);
+    extractAndValidateToken: (token: string, realm: string, req: IncomingMessage & Req) => MaybePromise<Token>;
+    fallbackTokenFetcher?: (req: IncomingMessage & Req) => MaybePromise<string | undefined>;
+    closeOnExpiry?: boolean;
+    softCloseBufferTime?: number;
+    onSoftCloseError?: ServerErrorCallback;
+}
+interface JWTToken {
+    nbf?: number;
+    exp?: number;
+    scopes?: Record<string, boolean> | string[] | string;
+}
+declare function requireBearerAuth<Req = {}, Token = JWTToken>({ realm, extractAndValidateToken, fallbackTokenFetcher, closeOnExpiry, softCloseBufferTime, onSoftCloseError, }: BearerAuthOptions<Req, Token>): RequestHandler<Req> & UpgradeHandler<Req>;
+declare const getAuthData: <Token>(req: IncomingMessage) => Token | null;
+declare const hasAuthScope: (req: IncomingMessage, scope: string) => boolean;
+declare const requireAuthScope: (scope: string) => RequestHandler & UpgradeHandler;
+
+declare function generateWeakETag(contentEncoding: string | number | string[] | undefined, stats: Pick<Stats, 'mtimeMs' | 'size'>): string;
+declare function generateStrongETag(file: string | FileHandle): Promise<string>;
+
+interface HTTPRange {
+    ranges: RangePart[];
+    totalSize?: number | undefined;
+}
+interface RangePart {
+    start: number;
+    end: number;
+}
+interface SimplifyRangeOptions {
+    forceSequential?: boolean;
+    mergeOverlapDistance?: number;
+}
+declare function simplifyRange(original: HTTPRange, { forceSequential, mergeOverlapDistance }?: SimplifyRangeOptions): HTTPRange;
+
+declare function getAuthorization(req: IncomingMessage): [string, string] | undefined;
+declare function getCharset(req: IncomingMessage): string | undefined;
+declare function getIfRange(req: IncomingMessage): {
+    etag?: string[] | undefined;
+    modifiedSeconds?: number | undefined;
+};
+interface GetRangeOptions {
+    /**
+     * Maximum number of sequential, non-overlapping ranges a client can request in a
+     * single message.
+     *
+     * Typical browser clients only request a single range. In rare cases, clients may
+     * request 2 ranges. Bespoke clients may be able to make use of more ranges.
+     *
+     * @default 10
+     */
+    maxRanges?: number;
+    /**
+     * Maximum number of ranges a client can request in a single message if any ranges are
+     * non-sequential (i.e. a later range begins at lower offset than an earlier range).
+     *
+     * As suggested in https://datatracker.ietf.org/doc/html/rfc7233, this uses a default
+     * limit of 2, as more ranges are likely to be a broken or malicious client.
+     *
+     * @default 2
+     */
+    maxNonSequential?: number;
+    /**
+     * Maximum number of ranges a client can request in a single message if any ranges are
+     * overlapping.
+     *
+     * As suggested in https://datatracker.ietf.org/doc/html/rfc7233, this uses a default
+     * limit of 2, as more ranges are likely to be a broken or malicious client.
+     *
+     * @default 2
+     */
+    maxWithOverlap?: number;
+}
+declare function getRange(req: IncomingMessage, totalSize: number, { maxRanges, maxNonSequential, maxWithOverlap }?: GetRangeOptions): HTTPRange | undefined;
+interface QualityValue {
+    name: string;
+    specifiers: Map<string, string>;
+    specificity: number;
+    q: number;
+}
+declare function readHTTPUnquotedCommaSeparated(raw: LooseHeaderValue | undefined): string[] | undefined;
+declare function readHTTPInteger(raw: string | undefined): number | undefined;
+declare function readHTTPQualityValues(raw: string | undefined): QualityValue[] | undefined;
+declare function readHTTPKeyValues(raw: string): Map<string, string>;
+declare function readHTTPDateSeconds(raw: LooseHeaderValue | undefined): number | undefined;
+type LooseHeaderValue = string | number | string[];
+
+declare const HEADERS: {
+    mime: string;
+    language: string;
+    encoding: string;
+};
+type NegotiationType = keyof typeof HEADERS;
+interface FileNegotiation {
+    type: NegotiationType;
+    options: FileNegotiationOption[];
+}
+interface FileNegotiationOption {
+    /**
+     * Value to match in `Accept-*` header.
+     * The comparison is case-insensitive.
+     *
+     * @example 'gzip'
+     * @example 'en-GB'
+     * @example /^en/
+     * @example 'text/html'
+     * @example /^text\//
+     */
+    match: string | RegExp;
+    /**
+     * Override value to return in `Content-Type` or `Content-Encoding`.
+     * You can use this to give a concrete type when matching against a wildcard:
+     *
+     * @example { match: 'text/*', as: 'text/plain', file: '{base}.txt' }
+     */
+    as?: string | undefined;
+    /**
+     * Filename modifier to apply. Several tokens are available:
+     *
+     * - `{file}` - the original filename (does not include the path)
+     * - `{base}` - the part of the original filename before the last `.` (or the entire filename if there is no dot)
+     * - `{ext}` - the original file extension, including the `.` (or blank of there is no dot)
+     *
+     * The resulting filename must not contain any path components (i.e. `/` and `\` are not allowed)
+     *
+     * @example '{file}.gz'
+     * @example '{base}-en{ext}'
+     * @example 'negotiated-{file}'
+     */
+    file: string;
+}
+declare const ENCODING_MAPPING: {
+    zstd: string;
+    br: string;
+    gzip: string;
+    deflate: string;
+    identity: string;
+};
+type FileEncodingFormat = keyof typeof ENCODING_MAPPING;
+declare const negotiateEncoding: (options: FileEncodingFormat[] | Record<FileEncodingFormat, string>) => FileNegotiation;
+interface NegotiationOutputInfo {
+    mime?: string | undefined;
+    language?: string | undefined;
+    encoding?: string | undefined;
+}
+interface NegotiationOutput {
+    filename: string;
+    info: NegotiationOutputInfo;
+}
+type NegotiationInput = Partial<Record<NegotiationType, QualityValue[] | undefined>>;
+interface Negotiator {
+    options(base: string, negotiation: NegotiationInput): Generator<NegotiationOutput, undefined, undefined>;
+    vary: string;
+}
+declare function makeNegotiator(rules: FileNegotiation[], maxFailedAttempts?: number): Negotiator;
+
+interface FileFinderOptions {
+    /**
+     * Also serve files from sub-directories.
+     * Can be set to a number to control the depth of subdirectories served (where 0 means no
+     * subdirectories).
+     *
+     * @default true
+     */
+    subDirectories?: boolean | number | undefined;
+    /**
+     * Configure case sensitivity of paths.
+     *
+     * `exact`: ensure that the path exactly matches the filesystem, even if the filesystem
+     * itself is case insensitive.
+     *
+     * `filesystem`: use the case sensitivity of the filesystem.
+     *
+     * `force-lowercase`: lowercase all requests before forwarding to the filesystem (this
+     * can achieve case insensitivity on otherwise case sensitive filesystems, but only if
+     * all files and folders are stored as lowercase).
+     *
+     * @default 'exact'
+     */
+    caseSensitive?: 'exact' | 'filesystem' | 'force-lowercase' | undefined;
+    /**
+     * Allow serving dotfiles.
+     * If `true`, all dotfiles will be available (note this can be a security risk if you have
+     * sensitive hidden files or directories in the directory being served, such as `.git`).
+     * If you only need some dotfiles to be made available, you can use `permit` instead, which
+     * lets you allow specific file / directory names.
+     *
+     * @default false
+     */
+    allowAllDotfiles?: boolean | undefined;
+    /**
+     * Allow serving files which begin or end with a tilde.
+     * These are commonly backup files (e.g. generated by vim when editing a file), and may or
+     * may not be a security risk to expose, depending on your setup.
+     * If `true`, all tilde files will be available.
+     * If you only need some tilde files to be made available, you can use `permit` instead, which
+     * lets you allow specific file / directory names.
+     *
+     * @default false
+     */
+    allowAllTildefiles?: boolean | undefined;
+    /**
+     * Serve index files when requested directly (e.g. `/foo/index.htm`).
+     * By default, index files (listed in `indexFiles`) are only served if the directory is requested.
+     *
+     * @default false
+     */
+    allowDirectIndexAccess?: boolean | undefined;
+    /**
+     * Hide arbitrary files from direct access. For example, when supporting content negotiation
+     * you may wish to block direct access to the "negotiated" variants of files such as `/\.gz$/`.
+     *
+     * Matches are performed on each path component. If any match, the file is hidden. Regular
+     * expressions are automatically made case insensitive if `caseSensitive` is `'filesystem'` or
+     * `'force-lowercase'`
+     *
+     * In cases where both match the same path component, `allow` overrides `hide`.
+     *
+     * @default []
+     */
+    hide?: (string | RegExp)[] | undefined;
+    /**
+     * Allow access to specific files which would otherwise be blocked as a dotfile, tilde file, or
+     * hidden by `hide`.
+     *
+     * @default ['.well-known']
+     */
+    allow?: string[] | undefined;
+    /**
+     * Files to look for if a directory is requested.
+     * Note that direct access to these files will be blocked unless `allowDirectIndexAccess` is `true`.
+     *
+     * If an empty list is provided, no index files will be served.
+     *
+     * @default ['index.htm', 'index.html']
+     */
+    indexFiles?: string[] | undefined;
+    /**
+     * Content negotiation rules to apply to files.
+     *
+     * This can be used to respond to the `Accept`, `Accept-Language`, and `Accept-Encoding` headers.
+     *
+     * For example: on a server with `foo.txt`, `foo.txt.gz`, and a negotiation rule mapping
+     * `gzip` => `{name}.gz`:
+     * - users requesting `foo.txt` may get `foo.txt.gz` with `Content-Encoding: gzip` if their
+     *   client supports gzip encoding
+     * - users requesting `foo.txt` may get `foo.txt` with no `Content-Encoding` if their client
+     *   does not support gzip encoding
+     *
+     * Note that file access is checked *before* content negotiation, so you must still provide a
+     * base "un-negotiated" file for each file you wish to serve (which will also be used in cases
+     * where users do not send any `Accept-*` headers, and where no match is found)
+     *
+     * Multiple rules can match simultaneously, if a specific enough file exists (for example you might
+     * have `foo-en.txt.gz` for `Accept-Language: en` and `Accept-Encoding: gzip`).
+     *
+     * In the case of conflicting rules, earlier rules take priority (so `encoding` rules should
+     * typically be specified last)
+     *
+     * See the helper `negotiateEncoding` for a simple way to support pre-compressed files.
+     *
+     * @default []
+     */
+    negotiation?: FileNegotiation[] | undefined;
+}
+interface FileFinderCore {
+    find(pathParts: string[], negotiation?: NegotiationInput): Promise<ResolvedFileInfo | null>;
+    readonly vary: string;
+}
+declare class FileFinder implements FileFinderCore {
+    readonly vary: string;
+    static build(absBasePath: string, options: FileFinderOptions): Promise<FileFinder>;
+    /**
+     * Find a file which matches the path.
+     *
+     * Note that the returned value contains an active `FileHandle`, which must be closed.
+     *
+     * @param pathParts the request path, split into separate components
+     * @param negotiation any client-sent negotiation options to apply
+     * @returns details about the resolved file (including an active `FileHandle`), or `null`
+     */
+    find(pathParts: string[], negotiation?: NegotiationInput): Promise<ResolvedFileInfo | null>;
+    precompute(): Promise<FileFinderCore>;
+}
+interface ResolvedFileInfo extends NegotiationOutputInfo {
+    handle: FileHandle;
+    canonicalPath: string;
+    negotiatedPath: string;
+    stats: Stats;
+}
+
+interface SavedFile {
+    path: string;
+    size: number;
+}
+interface TempFileStorage {
+    dir: string;
+    nextFile: () => string;
+    save: (stream: Readable | ReadableStream, options?: {
+        mode?: number | undefined;
+    }) => Promise<SavedFile>;
+}
+declare const makeTempFileStorage: (req: IncomingMessage) => Promise<TempFileStorage>;
+
+type ProxyHeader = 'forwarded' | 'x-forwarded-for' | 'x-forwarded-host' | 'x-forwarded-proto' | 'x-forwarded-protocol' | 'x-url-scheme' | 'via';
+interface GetClientOptions {
+    /**
+     * The number of proxies to trust.
+     *
+     * Although `trustedProxyAddresses` makes it easier to guarantee security, specifying a count of
+     * proxies is useful in cases where the IP of proxies is not known or can change.
+     *
+     * This should be set to the number of proxies in the chain for your deployment: 0 when exposed
+     * directly to the internet, 1 when running behind a proxy, 2 when using a local reverse proxy as
+     * well as a load balancer, etc.
+     *
+     * Note: you must make sure there is no way to access your server without going through at least
+     * this many proxies, otherwise users will be able to spoof their client details, such as IP
+     * address, requested hostname, and connection protocol.
+     *
+     * @default 0 if trustedProxyAddresses is not set
+     * @default infinity if trustedProxyAddresses is set
+     */
+    trustedProxyCount?: number;
+    /**
+     * The proxies to trust.
+     *
+     * For maximum security this can be an array of IPv4 or IPv6 addresses (or CIDR ranges) of
+     * trusted proxies. You can also specify alias names here, for cases where a proxy will be
+     * labelled by an alias by the next proxy in the chain.
+     *
+     * @default none (trust all proxies within trustedProxyCount hops)
+     */
+    trustedProxyAddresses?: string[];
+    /**
+     * The headers which are set (or cleared) by your proxy, and can therefore be trusted.
+     *
+     * To use proxy data, you must explicitly configure these headers to match those set by your
+     * proxy. Do not list headers which are not modified by your proxy, as this will allow clients
+     * to spoof data.
+     *
+     * @default [] (no headers are trusted)
+     */
+    trustedHeaders: ProxyHeader[];
+}
+declare function makeGetClient({ trustedProxyCount, trustedProxyAddresses, trustedHeaders, }: GetClientOptions): (req: IncomingMessage) => ProxyChain;
+interface ProxyChain {
+    trusted: ProxyNode[];
+    untrusted: ProxyNode[];
+    outwardChain: ProxyNode[];
+    edge: ProxyNode;
+}
+interface ProxyNode {
+    client: Address | undefined;
+    server: Address | undefined;
+    host: string | undefined;
+    proto: string | undefined;
+}
+
+type ProxyRequestHeaderAdapter = (request: IncomingMessage, headers: OutgoingHttpHeaders) => OutgoingHttpHeaders;
+type ProxyResponseHeaderAdapter = (request: IncomingMessage, proxyResponse: IncomingMessage, headers: OutgoingHttpHeaders) => OutgoingHttpHeaders;
+declare function removeForwarded(_: IncomingMessage, headers: IncomingHttpHeaders): OutgoingHttpHeaders;
+declare function replaceForwarded(req: IncomingMessage, headers: IncomingHttpHeaders): OutgoingHttpHeaders;
+declare const sanitiseAndAppendForwarded: (getClient: (req: IncomingMessage) => {
+    outwardChain: ProxyNode[];
+    trusted: ProxyNode[];
+}, { onlyTrusted }?: {
+    onlyTrusted?: boolean | undefined;
+}) => (req: IncomingMessage, headers: IncomingHttpHeaders) => OutgoingHttpHeaders;
+declare function simpleAppendForwarded(req: IncomingMessage, headers: IncomingHttpHeaders): OutgoingHttpHeaders;
+
+interface ProxyOptions extends AgentOptions {
+    agent?: Agent | Agent$1 | undefined;
+    /**
+     * A list of headers to remove from proxied requests (runs before `requestHeaders`).
+     *
+     * @default ['connection', 'expect', 'host', 'keep-alive', 'proxy-authorization', 'transfer-encoding', 'upgrade', 'via']
+     */
+    blockRequestHeaders?: string[] | undefined;
+    /**
+     * A list of headers to remove from proxied responses (runs before `responseHeaders`).
+     *
+     * @default ['connection', 'keep-alive', 'transfer-encoding']
+     */
+    blockResponseHeaders?: string[] | undefined;
+    /**
+     * Mutators for the proxied request headers. e.g. `sanitiseAndAppendForwarded`.
+     */
+    requestHeaders?: ProxyRequestHeaderAdapter[] | undefined;
+    /**
+     * Mutators for the proxied response headers.
+     */
+    responseHeaders?: ProxyResponseHeaderAdapter[] | undefined;
+}
+declare function proxy(forwardHost: string, { blockRequestHeaders, requestHeaders, blockResponseHeaders, responseHeaders, agent, keepAlive, maxSockets, ...options }?: ProxyOptions): RequestHandler<unknown>;
+
+declare function registerCharset(charset: string, transformerFactory: (options: TextDecoderOptions) => TransformStream<Uint8Array, string>): void;
+declare function registerUTF32(): void;
+
+declare function resetMime(): void;
+/**
+ * Reads mime types from an Apache .types file format.
+ * See https://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types for an example.
+ */
+declare function readMimeTypes(types: string): Map<string, string>;
+declare function decompressMime(definitions: string): Map<string, string>;
+declare function registerMime(definitions: Map<string, string>): void;
+declare function getMime(ext: string, charset?: string): string;
+
+declare function checkIfModified(req: IncomingMessage, res: ServerResponse, fileStats: Pick<Stats, 'mtimeMs' | 'size'>): boolean;
+declare function checkIfRange(req: IncomingMessage, res: ServerResponse, fileStats: Pick<Stats, 'mtimeMs' | 'size'>): boolean;
+declare function compareETag(res: ServerResponse, stats: Pick<Stats, 'mtimeMs' | 'size'>, etags: string[]): boolean;
+
+interface GetBodyOptions {
+    maxExpandedLength?: number;
+    maxContentLength?: number;
+    maxEncodingSteps?: number;
+}
+interface GetBodyTextOptions extends GetBodyOptions, TextDecoderOptions {
+    defaultCharset?: string;
+}
+interface GetBodyJsonOptions extends GetBodyOptions, TextDecoderOptions {
+}
+declare function getBodyStream(req: IncomingMessage, { maxExpandedLength, maxContentLength, maxEncodingSteps, }?: GetBodyOptions): ReadableStream<Uint8Array>;
+declare function getBodyTextStream(req: IncomingMessage, options?: GetBodyTextOptions): ReadableStream<string>;
+declare function getBodyText(req: IncomingMessage, options?: GetBodyTextOptions): Promise<string>;
+declare function getBodyJson(req: IncomingMessage, options?: GetBodyJsonOptions): Promise<unknown>;
+
+declare function acceptBody(req: IncomingMessage): void;
+
+declare function getFormFields(req: IncomingMessage, { allowMultipart, closeAfterErrorDelay, limits }?: GetFormFieldsConfig): AsyncIterable<FormField, unknown, undefined>;
+declare function getFormData(req: IncomingMessage, config?: GetFormDataConfig): Promise<AugmentedFormData>;
+interface GetFormFieldsConfig {
+    allowMultipart?: boolean;
+    closeAfterErrorDelay?: number;
+    limits?: Limits;
+}
+interface GetFormDataConfig extends GetFormFieldsConfig {
+    /** true to apply .trim() to all field values */
+    trimAllValues?: boolean;
+    /** function to apply to all uploaded files (e.g. to check available disk space) */
+    preCheckFile?: PreCheckFile;
+}
+type PreCheckFile = (info: PreCheckFileInfo) => MaybePromise<PostCheckFile | void>;
+interface PreCheckFileInfo {
+    fieldName: string;
+    filename: string;
+    encoding: string;
+    mimeType: string;
+    maxBytes: number | undefined;
+}
+type PostCheckFile = (actual: PostCheckFileInfo) => MaybePromise<void>;
+interface PostCheckFileInfo {
+    actualBytes: number;
+}
+type FormField = {
+    name: string;
+    mimeType: string;
+    encoding: string;
+} & ({
+    type: 'string';
+    value: string;
+} | {
+    type: 'file';
+    value: Readable;
+    filename: string;
+});
+interface AugmentedFormData extends FormData {
+    getTempFilePath(file: Blob): string;
+    getBoolean(name: string): boolean | null;
+}
+interface Limits {
+    /**
+     * Max field name size (in bytes).
+     *
+     * @default 100
+     */
+    fieldNameSize?: number | undefined;
+    /**
+     * Max field value size (in bytes).
+     *
+     * @default 1048576 (1MB)
+     */
+    fieldSize?: number | undefined;
+    /**
+     * Max number of non-file fields.
+     *
+     * @default Infinity
+     */
+    fields?: number | undefined;
+    /**
+     * For multipart forms, the max file size (in bytes).
+     *
+     * @default Infinity
+     */
+    fileSize?: number | undefined;
+    /**
+     * For multipart forms, the max number of file fields.
+     *
+     * @default Infinity
+     */
+    files?: number | undefined;
+    /**
+     * For multipart forms, the max number of parts (fields + files).
+     *
+     * @default Infinity
+     */
+    parts?: number | undefined;
+    /**
+     * For multipart forms, the max number of header key-value pairs to parse.
+     *
+     * @default 2000 (same as node's http module)
+     */
+    headerPairs?: number | undefined;
+}
+
+declare function getRemainingPathComponents(req: IncomingMessage, { rejectPotentiallyUnsafe }?: {
+    rejectPotentiallyUnsafe?: boolean | undefined;
+}): string[];
+
+interface CSVOptions {
+    /**
+     * The delimiter to use between cells
+     * @default ','
+     */
+    delimiter?: string | Uint8Array;
+    /**
+     * The delimiter to use between rows
+     * @default '\n'
+     */
+    newline?: string | Uint8Array;
+    /**
+     * The quote character to use. Typically should be `"` or (if the target application supports it) `'`
+     * @default '"'
+     */
+    quote?: string;
+    /**
+     * The text encoding to use.
+     * @default 'utf-8'
+     */
+    encoding?: BufferEncoding;
+    /**
+     * For use with `ServerResponse` targets.
+     * If `true`, adds header=present to the mime type; if `false`, adds header=absent to the mime type.
+     * @default undefined
+     */
+    headerRow?: boolean | undefined;
+    /**
+     * If `true`, will call `end()` on target stream after writing.
+     * @default true
+     */
+    end?: boolean;
+}
+type MaybeAsyncIterable<T> = Iterable<T> | AsyncIterable<T>;
+/**
+ * Output a CSV formatted table, using the format from RFC4180.
+ * Specifically:
+ * - lines are separated by newlines;
+ * - cells are separated by commas;
+ * - cells containing whitespace, commas, newlines, etc. are quoted with double quotes;
+ * - double quotes appearing inside cell values are escaped by doubling: `"a""b"`.
+ *
+ * The line and cell delimiters can be configured (e.g. `{ delimiter: '\t', newline: '\r\n' }`)
+ */
+declare function sendCSVStream(target: Writable, table: MaybeAsyncIterable<MaybeAsyncIterable<string | null | undefined>>, { delimiter, newline, quote, encoding, headerRow, end, }?: CSVOptions): Promise<void>;
+
+declare function sendFile(req: IncomingMessage, res: ServerResponse, file: string | FileHandle | Readable | ReadableStream<Uint8Array>, fileStats: Pick<Stats, 'mtimeMs' | 'size'> | null, options?: GetRangeOptions & SimplifyRangeOptions): Promise<void>;
+
+interface JSONOptions {
+    replacer?: ((this: unknown, key: string, value: unknown) => unknown) | (number | string)[] | null;
+    space?: string | number;
+    undefinedAsNull?: boolean;
+    encoding?: BufferEncoding;
+    end?: boolean;
+}
+declare function sendJSON(target: Writable, entity: unknown, { replacer, space, undefinedAsNull, encoding, end }?: JSONOptions): void;
+declare function sendJSONStream(target: Writable, entity: unknown, { replacer, space, undefinedAsNull, encoding, end, }?: JSONOptions): Promise<void>;
+
+declare function sendRanges(req: IncomingMessage, res: ServerResponse, file: string | FileHandle | Readable | ReadableStream<Uint8Array>, httpRange: HTTPRange): Promise<void>;
+
+interface ServerSentEventsOptions {
+    keepaliveInterval?: number;
+    softCloseReconnectDelay?: number;
+    softCloseReconnectStagger?: number;
+}
+interface ServerSentEvent {
+    event?: string;
+    data?: string;
+    id?: string;
+    reconnectDelay?: number;
+}
+declare class ServerSentEvents {
+    constructor(req: IncomingMessage, res: ServerResponse, { keepaliveInterval, softCloseReconnectDelay, softCloseReconnectStagger, }?: ServerSentEventsOptions);
+    get signal(): AbortSignal;
+    get open(): boolean;
+    ping(): void;
+    send({ event, id, data, reconnectDelay }: ServerSentEvent): Promise<void>;
+    sendFields(parts: [string, string | undefined][]): Promise<void>;
+    close(reconnectDelay?: number, reconnectStagger?: number): Promise<void>;
+}
+
+interface FileServerOptions extends FileFinderOptions {
+    /**
+     * The mode of serving files to use.
+     *
+     * 'dynamic' checks the filesystem for each request.
+     * This is a good choice for local development, and for production in cases where files in a
+     * directory are able to change at runtime (e.g. uploaded content).
+     *
+     * 'static-paths' scans the directory at startup then uses an in-memory reference to check
+     * requested paths.
+     * This can improve performance and increase security, as long as the list of avalable files
+     * will not change at runtime. The contents of the files are still loaded for each request.
+     * This is usually a good choice for production deployments.
+     *
+     * @default 'dynamic'
+     */
+    mode?: 'dynamic' | 'static-paths' | undefined;
+    /**
+     * Serve a file if the requested path is not found.
+     * By default, the handler will return `CONTINUE`, but by providing this option you can
+     * automatically return a particular file as fallback content (e.g. for Single-Page-Apps).
+     *
+     * Compression, cache control, and range requests will continue to work as usual.
+     */
+    fallback?: FallbackOptions | undefined;
+    /**
+     * A function to call when a file is being served. Can modify headers in the response.
+     * The default implementation is:
+     *
+     *  ```
+     *  res.setHeader('etag', generateWeakETag(res.getHeader('content-encoding'), file.stats));
+     *  res.setHeader('last-modified', file.stats.mtime.toUTCString());
+     *  ```
+     *
+     * If you override this function, you must decide which cache headers you wish to set.
+     *
+     * This function is called after the `Content-Type` and `Content-Encoding` headers have been set,
+     * so you can inspect those if you need to know the mime type or encoding of the response, or
+     * change them if you want to set different values.
+     *
+     * @param req
+     * @param res
+     * @param file information about the file, including `fs.Stats` and an active `FileHandle`
+     * @param isFallback `true` if the file is being served as a fallback (e.g. error page or Single-Page-App)
+     */
+    callback?: ((req: IncomingMessage, res: ServerResponse, file: ResolvedFileInfo, isFallback: boolean) => MaybePromise<void>) | undefined;
+}
+interface FallbackOptions {
+    /**
+     * The status code to return with the fallback content.
+     *
+     * @default 200 (OK)
+     */
+    statusCode?: number | undefined;
+    /**
+     * The path of the fallback content to use.
+     */
+    filePath: string;
+}
+/**
+ * Set up a server for static files in a directory. The options are secure by default.
+ * Requests for files which are not permitted or do not exist will return NEXT_ROUTE and can be
+ * handled by subsequent routes.
+ *
+ * @param basePath the path to the directory to serve (relative paths are to the current working directory)
+ * @param options custom configuration to apply
+ * @returns a promise of a server handler function (note this should be `await`ed before being used as a handler!)
+ */
+declare const fileServer: (basePath: string, { mode, fallback, callback, ...options }?: FileServerOptions) => Promise<RequestHandler>;
+declare function setDefaultCacheHeaders(req: IncomingMessage, res: ServerResponse, file: ResolvedFileInfo): void;
+
+interface InternalWebSocketServerOptions {
+    noServer?: true;
+    clientTracking?: false;
+    WebSocket?: any;
+}
+type ForbiddenWebSocketServerOptions = 'backlog' | 'server' | 'noServer' | 'clientTracking' | 'host' | 'port' | 'path' | 'verifyClient';
+declare class WebSocketServer<T, Options> {
+    constructor(options: Options);
+    handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer, callback: (ws: T) => void): void;
+    once(event: 'wsClientError', handler: (error: Error) => void): void;
+    off(event: 'wsClientError', handler: (error: Error) => void): void;
+}
+interface ClosableWebSocket {
+    close(status: number, message?: string): void;
+}
+interface WebSocketOptions {
+    softCloseStatusCode?: number | undefined;
+}
+declare function makeAcceptWebSocket<T extends ClosableWebSocket, PassThroughOptions>(wsServerClass: typeof WebSocketServer<T, InternalWebSocketServerOptions & PassThroughOptions>, { softCloseStatusCode, ...options }?: Partial<PassThroughOptions & Record<ForbiddenWebSocketServerOptions, never>> & {
+    WebSocket?: (new (...args: any) => T) | undefined;
+} & WebSocketOptions): (req: IncomingMessage) => Promise<T>;
+
+type MessageHandler = ((data: string | Buffer) => void) & ((data: Buffer, isBinary: boolean) => void);
+type CloseHandler = () => void;
+interface ListenableWebSocket {
+    on(event: 'message', handler: MessageHandler): void;
+    on(event: 'close', handler: CloseHandler): void;
+    off(event: 'message', handler: MessageHandler): void;
+    off(event: 'close', handler: CloseHandler): void;
+    readyState?: number;
+}
+declare class WebSocketMessage {
+    readonly data: Buffer;
+    readonly isBinary: boolean;
+    constructor(data: Buffer, isBinary: boolean);
+    get text(): string;
+    get binary(): Buffer<ArrayBufferLike>;
+}
+interface WebSocketMessagesOptions {
+    limit?: number;
+    signal?: AbortSignal | undefined;
+}
+declare class WebSocketMessages implements AsyncIterable<WebSocketMessage, unknown, undefined> {
+    readonly detach: () => void;
+    constructor(ws: ListenableWebSocket, { limit, signal }?: WebSocketMessagesOptions);
+    next(timeout?: number): Promise<WebSocketMessage>;
+    [Symbol.asyncIterator](): AsyncIterator<WebSocketMessage, unknown, undefined>;
+}
+declare function nextWebSocketMessage(ws: ListenableWebSocket, { timeout, signal }?: {
+    timeout?: number;
+    signal?: AbortSignal;
+}): Promise<WebSocketMessage>;
+
+declare function isWebSocketRequest(req: IncomingMessage): boolean;
+declare const getWebSocketOrigin: (req: IncomingMessage) => string | undefined;
+/**
+ * Factory for a fallback authentication token fetcher for websockets. Browsers do not allow setting the
+ * Authorization header when creating a websocket, so this allows the token to be sent as the first message
+ * instead.
+ *
+ * @param acceptWebSocket a function for accepting a websocket (e.g. `makeAcceptWebSocket(WebSocketServer)`)
+ * @returns a function suitable for use with `requireBearerAuth`'s `fallbackTokenFetcher` option.
+ */
+declare const makeWebSocketFallbackTokenFetcher: <Req>(acceptWebSocket: (req: IncomingMessage & Req) => Promise<ListenableWebSocket>, timeout?: number) => (req: IncomingMessage & Req) => Promise<string | undefined>;
+
+interface WebSocketErrorOptions {
+    message?: string;
+    statusMessage?: string;
+    cause?: unknown;
+}
+declare class WebSocketError extends Error {
+    readonly statusCode: number;
+    readonly statusMessage: string;
+    constructor(statusCode: number, { message, statusMessage, ...options }?: WebSocketErrorOptions);
+    static readonly NORMAL_CLOSURE = 1000;
+    static readonly GOING_AWAY = 1001;
+    static readonly UNSUPPORTED_DATA = 1003;
+    static readonly POLICY_VIOLATION = 1008;
+    static readonly MESSAGE_TOO_BIG = 1009;
+    static readonly INTERNAL_SERVER_ERROR = 1011;
+    static readonly SERVICE_RESTART = 1012;
+    static readonly TRY_AGAIN_LATER = 1013;
+    static readonly BAD_GATEWAY = 1014;
+}
+
+interface Property<T> {
+    factory: (req: IncomingMessage) => T;
+    set(req: IncomingMessage, value: T): void;
+    get(req: IncomingMessage): T;
+    clear(req: IncomingMessage): void;
+}
+declare function makeProperty<T>(defaultValue: T | ((req: IncomingMessage) => T)): Property<T>;
+declare const makeMemo: <T, Args extends any[] = []>(fn: (req: IncomingMessage, ...args: Args) => T, ...args: Args) => ((req: IncomingMessage) => T);
+declare function setProperty<T>(req: IncomingMessage, property: Property<T>, value: T): void;
+declare function getProperty<T>(req: IncomingMessage, property: Property<T>): T;
+declare function clearProperty<T>(req: IncomingMessage, property: Property<T>): void;
+
+export { BlockingQueue, CONTINUE, FileFinder, HTTPError, NEXT_ROUTE, NEXT_ROUTER, Queue, Router, STOP, ServerSentEvents, WebListener, WebSocketError, WebSocketMessage, WebSocketMessages, acceptBody, acceptUpgrade, addTeardown, anyHandler, checkIfModified, checkIfRange, clearProperty, compareETag, decompressMime, defer, errorHandler, fileServer, findCause, generateStrongETag, generateWeakETag, getAbortSignal, getAbsolutePath, getAddressURL, getAuthData, getAuthorization, getBodyJson, getBodyStream, getBodyText, getBodyTextStream, getCharset, getFormData, getFormFields, getIfRange, getMime, getPathParameter, getPathParameters, getProperty, getQuery, getRange, getRemainingPathComponents, getSearch, getSearchParams, getWebSocketOrigin, hasAuthScope, isSoftClosed, isWebSocketRequest, makeAcceptWebSocket, makeAddressTester, makeGetClient, makeMemo, makeNegotiator, makeProperty, makeTempFileStorage, makeWebSocketFallbackTokenFetcher, negotiateEncoding, nextWebSocketMessage, parseAddress, proxy, readHTTPDateSeconds, readHTTPInteger, readHTTPKeyValues, readHTTPQualityValues, readHTTPUnquotedCommaSeparated, readMimeTypes, registerCharset, registerMime, registerUTF32, removeForwarded, replaceForwarded, requestHandler, requireAuthScope, requireBearerAuth, resetMime, restoreAbsolutePath, sanitiseAndAppendForwarded, sendCSVStream, sendFile, sendJSON, sendJSONStream, sendRanges, setDefaultCacheHeaders, setProperty, setSoftCloseHandler, simpleAppendForwarded, simplifyRange, toListeners, upgradeHandler };
+export type { AcceptUpgradeHandler, AcceptUpgradeResult, Address, AugmentedFormData, CSVOptions, CombinedServerOptions, CommonMethod, CommonUpgrade, ErrorHandler, FileFinderCore, FileFinderOptions, FileNegotiation, FileNegotiationOption, FileServerOptions, FormField, GetClientOptions, GetFormDataConfig, GetFormFieldsConfig, GetRangeOptions, HTTPErrorOptions, HTTPRange, HandlerResult, JSONOptions, ListenOptions, ListenerOptions, NativeListeners, NegotiationInput, NegotiationOutput, NegotiationOutputInfo, Negotiator, ParametersFromPath, PostCheckFile, PostCheckFileInfo, PreCheckFile, PreCheckFileInfo, Property, ProxyChain, ProxyNode, ProxyOptions, ProxyRequestHeaderAdapter, ProxyResponseHeaderAdapter, QualityValue, RangePart, RequestHandler, ResolvedFileInfo, ServerErrorCallback, ServerGeneralErrorCallback, ServerSentEvent, SimplifyRangeOptions, UpgradeHandler, UpgradeListener, WithPathParameters, WithoutPathParameters };