web-listener 1.2.1 → 1.3.0

package/index.d.ts

@@ -3,7 +3,7 @@ import { Duplex, Readable, Writable } from 'node:stream';
 import { AddressInfo } from 'node:net';
 import { FileHandle, CreateReadStreamOptions } from 'node:fs/promises';
 import { Mode, Stats, StatOptions, BigIntStats } from 'node:fs';
-import { ReadableStream, TransformStream } from 'node:stream/web';
+import { ReadableStream as ReadableStream$1, TransformStream } from 'node:stream/web';
 import { AgentOptions, Agent as Agent$1 } from 'node:https';
 
 type ClientErrorListener = (error: Error, socket: Duplex) => void;
@@ -16,7 +16,7 @@ interface Address {
     port: number | undefined;
 }
 declare function parseAddress(address: string | undefined): Address | undefined;
-declare function makeAddressTester(cidrRanges: string[]): (address: Address | undefined) => boolean;
+declare function makeAddressTester(cidrRanges: ReadonlyArray<string>): (address: Address | undefined) => boolean;
 
 declare class BlockingQueue<T> {
     constructor();
@@ -40,7 +40,8 @@ declare function findCause<T>(error: unknown, errorType: {
 
 declare function getAddressURL(addressInfo: string | Address | AddressInfo | null | undefined, protocol?: string): string;
 
-type AnyHeaders = Headers | [string, string][] | OutgoingHttpHeaders | Map<string, string | number | Readonly<string[]>> | undefined;
+type LooseHeaderValue = string | number | ReadonlyArray<string>;
+type AnyHeaders = Headers | ReadonlyArray<[string, string]> | OutgoingHttpHeaders | Map<string, LooseHeaderValue> | undefined;
 
 declare class Queue<T> {
     constructor(initialItem?: T);
@@ -52,15 +53,12 @@ declare class Queue<T> {
     [Symbol.iterator](): Iterator<T, unknown, undefined>;
 }
 
-interface CloseableReadable extends Readable {
-    close(): void;
-}
 interface ReadOnlyFileHandle extends Pick<FileHandle, 'stat' | 'close' | typeof Symbol.asyncDispose>, Partial<Pick<FileHandle, 'read' | 'readFile' | 'readLines' | 'readableWebStream' | 'readv'>> {
-    createReadStream(options?: CreateReadStreamOptions): CloseableReadable;
+    createReadStream(options?: CreateReadStreamOptions | undefined): Readable;
     noRandomAccess?: boolean | undefined;
 }
 
-declare const stringPredicate: (conditions: (string | RegExp)[] | string | RegExp | undefined, caseInsensitive: boolean) => ((value: string) => boolean);
+declare const stringPredicate: (conditions: ReadonlyArray<string | RegExp> | string | RegExp | undefined, caseInsensitive: boolean) => ((value: string) => boolean);
 
 declare class SharedFileHandle {
     constructor(path: string, flags?: number, mode?: Mode, closeDelay?: number);
@@ -77,7 +75,7 @@ type UpgradeErrorHandler = (error: unknown) => void;
 type SoftCloseHandler = (reason: string) => MaybePromise<void>;
 declare function setSoftCloseHandler(req: IncomingMessage, fn: SoftCloseHandler): void;
 declare const isSoftClosed: (req: IncomingMessage) => boolean;
-declare function scheduleClose(req: IncomingMessage, reason: string, hardCloseTimestamp: number, softCloseBufferTime?: number, onSoftCloseError?: ServerErrorCallback): void;
+declare function scheduleClose(req: IncomingMessage, reason: string, hardCloseTimestamp: number, softCloseBufferTime?: number, onSoftCloseError?: ServerErrorCallback | undefined): void;
 declare const defer: (req: IncomingMessage, fn: () => MaybePromise<void>) => void;
 declare const addTeardown: (req: IncomingMessage, fn: () => MaybePromise<void>) => void;
 declare const getAbortSignal: (req: IncomingMessage) => AbortSignal;
@@ -85,8 +83,8 @@ declare const getAbortSignal: (req: IncomingMessage) => AbortSignal;
 type AcceptUpgradeHandler<T, Req = {}> = (req: IncomingMessage & Req, socket: Duplex, head: Buffer) => Promise<AcceptUpgradeResult<T>>;
 interface AcceptUpgradeResult<T> {
     return: T;
-    onError?: UpgradeErrorHandler;
-    softCloseHandler?: SoftCloseHandler;
+    onError?: UpgradeErrorHandler | undefined;
+    softCloseHandler?: SoftCloseHandler | undefined;
 }
 declare function acceptUpgrade<T, Req = {}>(req: IncomingMessage & Req, upgrade: AcceptUpgradeHandler<T, Req>): Promise<T>;
 declare function delegateUpgrade(req: IncomingMessage): void;
@@ -104,15 +102,15 @@ type RequestHandlerFn<Req = {}> = (req: IncomingMessage & Req, res: ServerRespon
 interface RequestHandler<Req = {}> {
     handleRequest: RequestHandlerFn<Req>;
 }
-declare const requestHandler: <Req>(handler: RequestHandler<Req> | RequestHandlerFn<Req>) => RequestHandler<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>;
+declare const upgradeHandler: <Req = {}>(handler: UpgradeHandler<Req> | UpgradeHandlerFn<Req>, shouldUpgrade?: ShouldUpgradeFn<Req> | undefined) => UpgradeHandler<Req>;
+declare const anyHandler: <Req = {}>(handler: UpgradeHandlerFn<Req> & RequestHandlerFn<Req>, shouldUpgrade?: ShouldUpgradeFn<Req>) => RequestHandler<Req> & UpgradeHandler<Req>;
 type ErrorOutput = {
     response: ServerResponse;
     socket?: never;
@@ -127,9 +125,9 @@ type ErrorOutput = {
 type ErrorHandlerFn<Req = {}> = (error: unknown, req: IncomingMessage & Req, output: ErrorOutput) => MaybePromise<HandlerResult>;
 interface ErrorHandler<Req = {}> {
     handleError: ErrorHandlerFn<Req>;
-    shouldHandleError?: (error: unknown, req: IncomingMessage & Req, output: ErrorOutput) => boolean;
+    shouldHandleError?: ((error: unknown, req: IncomingMessage & Req, output: ErrorOutput) => boolean) | undefined;
 }
-declare const errorHandler: <Req>(handler: ErrorHandler<Req> | ErrorHandlerFn<Req>) => ErrorHandler<Req>;
+declare const errorHandler: <Req = {}>(handler: ErrorHandler<Req> | ErrorHandlerFn<Req>) => ErrorHandler<Req>;
 type TypedErrorHandlerFn<Error, Req = {}> = (error: Error, req: IncomingMessage & Req, response: ServerResponse) => MaybePromise<HandlerResult>;
 declare const typedErrorHandler: <Error, Req>(ErrorClass: abstract new (...args: any[]) => Error, handler: TypedErrorHandlerFn<Error, Req>) => ErrorHandler<Req>;
 type ConditionalErrorHandler = (<Error, Req>(condition: (x: unknown) => x is Error, handler: TypedErrorHandlerFn<Error, Req>) => ErrorHandler<Req>) & (<Req>(condition: (x: unknown) => boolean, handler: TypedErrorHandlerFn<unknown, Req>) => ErrorHandler<Req>);
@@ -147,12 +145,12 @@ interface NativeListenersOptions {
      *
      * The default implementation logs the error via `console.error` unless it is a `HTTPError` with `statusCode` < 500
      */
-    onError?: ServerGeneralErrorCallback;
+    onError?: ServerGeneralErrorCallback | undefined;
     /**
      * Number of milliseconds to wait before forcibly closing sockets which are left half-open by the client.
      * @default 500
      */
-    socketCloseTimeout?: number;
+    socketCloseTimeout?: number | undefined;
 }
 type ServerGeneralErrorCallback = (error: unknown, context: string, req: IncomingMessage | undefined) => void;
 interface NativeListeners {
@@ -222,7 +220,7 @@ declare const WebListener_base: TypedEventTarget<WebListener, {
 }>;
 declare class WebListener extends WebListener_base {
     constructor(handler: Handler);
-    attach(server: Server, options?: ListenerOptions): (reason?: string, existingConnectionTimeout?: number, forShutdown?: boolean, callback?: () => void) => NativeListeners;
+    attach(server: Server, options?: ListenerOptions): (reason?: string, existingConnectionTimeout?: number, forShutdown?: boolean, callback?: (() => void) | undefined) => NativeListeners;
     createServer(options?: ServerOptions & ListenerOptions): AugmentedServer;
     listen(port: number, host: string, options?: CombinedServerOptions): Promise<AugmentedServer>;
 }
@@ -239,7 +237,7 @@ interface AugmentedServer extends Server {
 interface HTTPErrorOptions {
     message?: string | undefined;
     statusMessage?: string | undefined;
-    headers?: AnyHeaders;
+    headers?: AnyHeaders | undefined;
     body?: string | undefined;
     cause?: unknown;
 }
@@ -295,9 +293,9 @@ declare const getQuery: (req: IncomingMessage, name: 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 RelaxedRequestHandler<Req = {}> = RequestHandlerFn<Req> | RequestHandler<Req> | ErrorHandler<Req> | null | undefined;
 type RelaxedRequestHandlerOrExplicitUpgrade<Req = {}> = RelaxedRequestHandler<Req> | UpgradeHandler<Req>;
-type RelaxedUpgradeHandler<Req = {}> = UpgradeHandlerFn<Req> | UpgradeHandler<Req> | ErrorHandler<Req>;
+type RelaxedUpgradeHandler<Req = {}> = UpgradeHandlerFn<Req> | UpgradeHandler<Req> | ErrorHandler<Req> | null | undefined;
 type MethodWrapper<Req, This> = <Path extends string>(path: ValidPath<Path>, ...handlers: RelaxedRequestHandler<Req & WithPathParameters<ParametersFromPath<Path>>>[]) => This;
 type UpgradeWrapper<Req, This> = <Path extends string>(path: ValidPath<Path>, ...handlers: RelaxedUpgradeHandler<Req & WithPathParameters<ParametersFromPath<Path>>>[]) => This;
 declare class Router<Req = {}> implements Handler<Req> {
@@ -440,9 +438,12 @@ declare const hasAuthScope: (req: IncomingMessage, scope: string) => boolean;
 declare const getAuthScopes: (req: IncomingMessage) => Set<string>;
 declare const requireAuthScope: (scope: string) => RequestHandler & UpgradeHandler;
 
-declare function generateWeakETag(contentEncoding: string | number | string[] | undefined, fileStats: Pick<Stats, 'mtimeMs' | 'size'>): string;
+declare function generateWeakETag(contentEncoding: LooseHeaderValue | undefined, fileStats: Pick<Stats, 'mtimeMs' | 'size'>): string;
 declare function generateStrongETag(file: string | Pick<ReadOnlyFileHandle, 'createReadStream'>): Promise<string>;
 
+type ContentEncoding = 'zstd' | 'br' | 'gzip' | 'deflate' | 'identity';
+type EncodingQuality = 'fast' | 'mid' | 'max';
+
 declare const FEATURES: {
     type: {
         _requestHeader: string;
@@ -462,9 +463,9 @@ interface FileNegotiation {
     /** Feature to negotiate ('type', 'language', or 'encoding') */
     feature: NegotiationFeature;
     /** Filename filter (only apply this negotiation for requests with filenames matching the pattern) */
-    match?: string | RegExp;
+    match?: string | RegExp | undefined;
     /** List of negotiation options available, ordered by server preference */
-    options: FileNegotiationOption[];
+    options: ReadonlyArray<FileNegotiationOption>;
 }
 interface FileNegotiationOption {
     /**
@@ -481,7 +482,7 @@ interface FileNegotiationOption {
      *
      * @example { value: 'text/plain', for: /^text\//, file: '{base}.txt' }
      */
-    for?: RegExp;
+    for?: RegExp | undefined;
     /**
      * Filename modifier to apply. Several tokens are available:
      *
@@ -497,8 +498,7 @@ interface FileNegotiationOption {
      */
     file: string;
 }
-type FileEncodingFormat = 'zstd' | 'br' | 'gzip' | 'deflate' | 'identity';
-declare const negotiateEncoding: (options: FileEncodingFormat[] | Record<FileEncodingFormat, string>) => FileNegotiation;
+declare const negotiateEncoding: (options: ReadonlyArray<ContentEncoding> | Record<ContentEncoding, string>) => FileNegotiation;
 type NegotiationOutputHeaders = {
     /** The negotiated mime type for the resolved file */
     'content-type'?: string;
@@ -535,79 +535,12 @@ declare class Negotiator {
      *
      * See the helper `negotiateEncoding` for a simple way to support pre-compressed files.
      */
-    constructor(rules: FileNegotiation[], { maxFailedAttempts }?: {
+    constructor(rules: ReadonlyArray<FileNegotiation>, { maxFailedAttempts }?: {
         maxFailedAttempts?: number | undefined;
     });
     options(base: string, reqHeaders: IncomingHttpHeaders): Generator<NegotiationOutput, undefined, undefined>;
 }
 
-interface CompressionInfo {
-    /** the path to the file */
-    file: string;
-    /** the mime type of the file */
-    mime: string;
-    /** the size of the original file in bytes */
-    rawSize: number;
-    /** the size of the smallest compressed version of the file in bytes */
-    bestSize: number;
-    /** the number of compressed files which were saved */
-    created: number;
-}
-interface CompressionOptions {
-    /**
-     * the minimum compression (in bytes) which must be achieved to save the file
-     * @default 0
-     */
-    minCompression?: number;
-    /**
-     * if `true`, existing compressed files which are no-longer relevant will be removed
-     * @default false
-     */
-    deleteObsolete?: boolean;
-    /**
-     * if `true`, the modified time of the compressed files will be set to match the modified time of
-     * the input file
-     * @default true
-     */
-    matchModifiedTime?: boolean;
-    /**
-     * Filter to apply to files (does not attempt to compress files if the function returns `false`)
-     * @param path the full path to the file
-     * @param mime the mime type of the file (if known, else 'application/binary')
-     * @returns `true` if the file should be compressed
-     * @default (_, mime) => !['image', 'video', 'audio', 'font'].includes(mime.split('/')[0])
-     */
-    filter?: (path: string, mime: string) => boolean;
-}
-declare function compressFileOffline(file: string, encodings: FileNegotiationOption[], { minCompression, deleteObsolete, matchModifiedTime, filter, }?: CompressionOptions): Promise<CompressionInfo>;
-declare function compressFilesInDir(dir: string, encodings: FileNegotiationOption[], options?: CompressionOptions): Promise<CompressionInfo[]>;
-
-declare const emitError: (req: IncomingMessage, error: unknown, context?: string) => void;
-
-interface JSONErrorHandlerOptions {
-    /**
-     * Only send a JSON response if the client sent `Accept: application/json`.
-     * @default true
-     */
-    onlyIfRequested?: boolean | undefined;
-    /**
-     * Emit the error to the current error listener.
-     * @default true
-     */
-    emitError?: boolean | undefined;
-    /**
-     * If set, forces a consistent HTTP status code (ignoring the status code from the error).
-     * @default undefined
-     */
-    forceStatus?: number | undefined;
-    /**
-     * The content-type to set on the response.
-     * @default 'application/json'
-     */
-    contentType?: string;
-}
-declare const jsonErrorHandler: (conversion: (error: HTTPError) => unknown, { onlyIfRequested, emitError: doEmitError, forceStatus, contentType, }?: JSONErrorHandlerOptions) => ErrorHandler;
-
 interface FileFinderOptions {
     /**
      * Also serve files from sub-directories.
@@ -672,14 +605,14 @@ interface FileFinderOptions {
      *
      * @default []
      */
-    hide?: (string | RegExp)[] | undefined;
+    hide?: ReadonlyArray<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;
+    allow?: ReadonlyArray<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`.
@@ -688,7 +621,7 @@ interface FileFinderOptions {
      *
      * @default ['index.htm', 'index.html']
      */
-    indexFiles?: string[] | undefined;
+    indexFiles?: ReadonlyArray<string> | undefined;
     /**
      * Suffixes to try appending if the requested file does not exist.
      *
@@ -696,7 +629,7 @@ interface FileFinderOptions {
      *
      * @default []
      */
-    implicitSuffixes?: string[] | undefined;
+    implicitSuffixes?: ReadonlyArray<string> | undefined;
     /**
      * Content negotiation to apply to files.
      *
@@ -711,8 +644,8 @@ interface FileFinderOptions {
     negotiator?: Negotiator | undefined;
 }
 interface FileFinder {
-    find(pathParts: string[], reqHeaders?: IncomingHttpHeaders, warnings?: string[] | undefined): Promise<ResolvedFileInfo | null>;
-    toNormalisedPath(pathParts: string[]): string[];
+    find(pathParts: ReadonlyArray<string>, reqHeaders?: IncomingHttpHeaders | undefined, warnings?: string[] | undefined): Promise<ResolvedFileInfo | null>;
+    toNormalisedPath(pathParts: ReadonlyArray<string>): ReadonlyArray<string>;
     isStaticListing: boolean;
     staticPaths?: () => Set<string>;
 }
@@ -729,6 +662,73 @@ interface ResolvedFileInfo {
     headers: NegotiationOutputHeaders;
 }
 
+interface CompressionInfo {
+    /** the path to the file */
+    file: string;
+    /** the mime type of the file */
+    mime: string;
+    /** the size of the original file in bytes */
+    rawSize: number;
+    /** the size of the smallest compressed version of the file in bytes */
+    bestSize: number;
+    /** the number of compressed files which were saved */
+    created: number;
+}
+interface CompressionOptions {
+    /**
+     * the minimum compression (in bytes) which must be achieved to save the file
+     * @default 0
+     */
+    minCompression?: number | undefined;
+    /**
+     * if `true`, existing compressed files which are no-longer relevant will be removed
+     * @default false
+     */
+    deleteObsolete?: boolean | undefined;
+    /**
+     * if `true`, the modified time of the compressed files will be set to match the modified time of
+     * the input file
+     * @default true
+     */
+    matchModifiedTime?: boolean | undefined;
+    /**
+     * Filter to apply to files (does not attempt to compress files if the function returns `false`)
+     * @param path the full path to the file
+     * @param mime the mime type of the file (if known, else 'application/binary')
+     * @returns `true` if the file should be compressed
+     * @default (_, mime) => !['image', 'video', 'audio', 'font'].includes(mime.split('/')[0])
+     */
+    filter?: ((path: string, mime: string) => boolean) | undefined;
+}
+declare function compressFileOffline(file: string, encodings: ReadonlyArray<FileNegotiationOption>, { minCompression, deleteObsolete, matchModifiedTime, filter, }?: CompressionOptions): Promise<CompressionInfo>;
+declare function compressFilesInDir(dir: string, encodings: ReadonlyArray<FileNegotiationOption>, options?: CompressionOptions & Pick<FileFinderOptions, 'subDirectories' | 'allowAllDotfiles' | 'allowAllTildefiles' | 'hide' | 'allow'>): Promise<CompressionInfo[]>;
+
+declare const emitError: (req: IncomingMessage, error: unknown, context?: string | undefined) => void;
+
+interface JSONErrorHandlerOptions {
+    /**
+     * Only send a JSON response if the client sent `Accept: application/json`.
+     * @default true
+     */
+    onlyIfRequested?: boolean | undefined;
+    /**
+     * Emit the error to the current error listener.
+     * @default true
+     */
+    emitError?: boolean | undefined;
+    /**
+     * If set, forces a consistent HTTP status code (ignoring the status code from the error).
+     * @default undefined
+     */
+    forceStatus?: number | undefined;
+    /**
+     * The content-type to set on the response.
+     * @default 'application/json'
+     */
+    contentType?: string | undefined;
+}
+declare const jsonErrorHandler: (conversion: (error: HTTPError) => unknown, { onlyIfRequested, emitError: doEmitError, forceStatus, contentType, }?: JSONErrorHandlerOptions) => ErrorHandler;
+
 declare const dynamicFileFinder: (baseDir: string, options?: FileFinderOptions) => Promise<FileFinder>;
 
 declare function staticFileFinder(baseDir: string, options?: FileFinderOptions): Promise<FileFinder & {
@@ -747,7 +747,7 @@ declare class ZipDirectory {
         path: string[];
         node: ZipFile;
     }, undefined, undefined>;
-    find(path: string[]): ZipNode | undefined;
+    find(path: ReadonlyArray<string>): ZipNode | undefined;
 }
 declare class ZipFile {
     readonly virtual: boolean;
@@ -755,13 +755,13 @@ declare class ZipFile {
     get zipFilePath(): string;
     get filesystemPath(): string;
     get crc32(): number;
-    stat(opts?: StatOptions & {
+    stat(opts?: (StatOptions & {
         bigint?: false | undefined;
-    }): Stats;
+    }) | undefined): Stats;
     stat(opts: StatOptions & {
         bigint: true;
     }): BigIntStats;
-    stat(opts?: StatOptions): Stats | BigIntStats;
+    stat(opts?: StatOptions | undefined): Stats | BigIntStats;
     open(): Promise<ReadOnlyFileHandle>;
 }
 
@@ -778,9 +778,9 @@ interface SavedFile {
 interface TempFileStorage {
     dir: string;
     nextFile: () => string;
-    save: (stream: Readable | ReadableStream, options?: {
+    save: (stream: Readable | ReadableStream$1, options?: {
         mode?: number | undefined;
-    }) => Promise<SavedFile>;
+    } | undefined) => Promise<SavedFile>;
 }
 declare const makeTempFileStorage: (req: IncomingMessage) => Promise<TempFileStorage>;
 
@@ -803,7 +803,7 @@ interface GetClientOptions {
      * @default 0 if trustedProxyAddresses is not set
      * @default infinity if trustedProxyAddresses is set
      */
-    trustedProxyCount?: number;
+    trustedProxyCount?: number | undefined;
     /**
      * The proxies to trust.
      *
@@ -813,7 +813,7 @@ interface GetClientOptions {
      *
      * @default none (trust all proxies within trustedProxyCount hops)
      */
-    trustedProxyAddresses?: string[];
+    trustedProxyAddresses?: ReadonlyArray<string> | undefined;
     /**
      * The headers which are set (or cleared) by your proxy, and can therefore be trusted.
      *
@@ -823,7 +823,7 @@ interface GetClientOptions {
      *
      * @default [] (no headers are trusted)
      */
-    trustedHeaders: ProxyHeader[];
+    trustedHeaders: ReadonlyArray<ProxyHeader>;
 }
 type GetClient = (req: IncomingMessage) => ProxyChain;
 declare function makeGetClient({ trustedProxyCount, trustedProxyAddresses, trustedHeaders, }: GetClientOptions): GetClient;
@@ -845,8 +845,8 @@ type ProxyResponseHeaderAdapter = (request: IncomingMessage, proxyResponse: Inco
 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[];
+    outwardChain: ReadonlyArray<ProxyNode>;
+    trusted: ReadonlyArray<ProxyNode>;
 }, { onlyTrusted }?: {
     onlyTrusted?: boolean | undefined;
 }) => (req: IncomingMessage, headers: IncomingHttpHeaders) => OutgoingHttpHeaders;
@@ -861,7 +861,7 @@ interface ProxyOptions extends AgentOptions {
      *
      * @default []
      */
-    blockRequestHeaders?: string[] | undefined;
+    blockRequestHeaders?: ReadonlyArray<string> | undefined;
     /**
      * A list of headers to remove from proxied responses (runs before `responseHeaders`).
      * Hop-by-hop headers (including standard hop-by-hop headers and
@@ -869,17 +869,17 @@ interface ProxyOptions extends AgentOptions {
      *
      * @default []
      */
-    blockResponseHeaders?: string[] | undefined;
+    blockResponseHeaders?: ReadonlyArray<string> | undefined;
     /**
      * Mutators for the proxied request headers. e.g. `replaceForwarded`.
      */
-    requestHeaders?: ProxyRequestHeaderAdapter[] | undefined;
+    requestHeaders?: ReadonlyArray<ProxyRequestHeaderAdapter> | undefined;
     /**
      * Mutators for the proxied response headers.
      */
-    responseHeaders?: ProxyResponseHeaderAdapter[] | undefined;
+    responseHeaders?: ReadonlyArray<ProxyResponseHeaderAdapter> | undefined;
 }
-declare function proxy(forwardHost: string | URL, { blockRequestHeaders, requestHeaders, blockResponseHeaders, responseHeaders, agent, ...options }?: ProxyOptions): RequestHandler<unknown>;
+declare function proxy(forwardHost: string | URL, { blockRequestHeaders, requestHeaders, blockResponseHeaders, responseHeaders, agent, ...options }?: ProxyOptions): RequestHandler<{}>;
 
 interface TextDecoderOptions {
     fatal?: boolean;
@@ -894,7 +894,7 @@ type DecoderStream = TransformStream<Uint8Array, string>;
 
 interface Charset {
     decoder: (options: TextDecoderOptions) => Decoder;
-    decoderStream?: (options: TextDecoderOptions) => DecoderStream;
+    decoderStream?: ((options: TextDecoderOptions) => DecoderStream) | undefined;
 }
 declare function registerCharset(charsetName: string, definition: Charset): void;
 declare function registerUTF32(): void;
@@ -913,36 +913,36 @@ declare function getMime(ext: string, charset?: string): string;
 
 declare function checkIfModified(req: IncomingMessage, res: ServerResponse, fileStats: Pick<Stats, 'mtimeMs' | 'size'> | null): boolean;
 declare function checkIfRange(req: IncomingMessage, res: ServerResponse, fileStats: Pick<Stats, 'mtimeMs' | 'size'>): boolean;
-declare function compareETag(res: ServerResponse, fileStats: Pick<Stats, 'mtimeMs' | 'size'> | null, etags: string[]): boolean;
+declare function compareETag(res: ServerResponse, fileStats: Pick<Stats, 'mtimeMs' | 'size'> | null, etags: ReadonlyArray<string>): boolean;
 
 interface GetBodyOptions {
     /**
      * The maximum content length after applying all decoding steps
      * @default Infinity
      */
-    maxContentBytes?: number;
+    maxContentBytes?: number | undefined;
     /**
      * The maximum content length as sent (before applying any decoding steps)
      * @default maxContentBytes
      */
-    maxNetworkBytes?: number;
+    maxNetworkBytes?: number | undefined;
     /**
      * The maximum number of content-encoding steps the client can specify.
      * Browsers typically do not use any content-encoding in requests, and it is unlikely that this would need to be set greater than 1 for any standard client.
      * @default 1
      */
-    maxEncodingSteps?: number;
+    maxEncodingSteps?: number | undefined;
 }
 interface GetBodyTextOptions extends GetBodyOptions, TextDecoderOptions {
-    defaultCharset?: string;
+    defaultCharset?: string | undefined;
 }
 interface GetBodyJSONOptions extends GetBodyOptions, TextDecoderOptions {
     reviver?: ((this: Record<string, unknown> | unknown[], key: string, value: unknown, context?: {
-        source?: string;
-    }) => unknown) | undefined;
+        source?: string | undefined;
+    } | undefined) => unknown) | undefined;
 }
-declare function getBodyStream(req: IncomingMessage, { maxContentBytes, maxNetworkBytes, maxEncodingSteps, }?: GetBodyOptions): ReadableStream<Uint8Array>;
-declare function getBodyTextStream(req: IncomingMessage, options?: GetBodyTextOptions): ReadableStream<string>;
+declare function getBodyStream(req: IncomingMessage, { maxContentBytes, maxNetworkBytes, maxEncodingSteps, }?: GetBodyOptions): ReadableStream$1<Uint8Array>;
+declare function getBodyTextStream(req: IncomingMessage, options?: GetBodyTextOptions): ReadableStream$1<string>;
 declare function getBodyText(req: IncomingMessage, options?: GetBodyTextOptions): Promise<string>;
 declare function getBodyJSON(req: IncomingMessage, options?: GetBodyJSONOptions): Promise<unknown>;
 
@@ -954,38 +954,38 @@ interface BusboyOptions {
      * `true` to block `multipart/form-data` (including file uploads). If set, only `application/x-www-form-urlencoded` is supported.
      * @default false
      */
-    blockMultipart?: boolean;
+    blockMultipart?: boolean | undefined;
     /**
      * `true` to preserve path information in filenames. `false` to only include the basename (omitting everything before the last `/` or `\`)
      * @default false
      */
-    preservePath?: boolean;
+    preservePath?: boolean | undefined;
     /**
      * High water mark to set on file streams.
      * @default 65536
      */
-    fileHwm?: number;
+    fileHwm?: number | undefined;
     /**
      * Default character set to use for reading name and filename from the content-disposition header in multipart content.
      * According to the standard this should be `latin1`, but most browsers use `utf-8`.
      * @default 'utf-8'
      */
-    defParamCharset?: string;
+    defParamCharset?: string | undefined;
     /**
      * Default character set to use for reading field content (and field names in urlencoded content).
      * @default 'utf-8'
      */
-    defCharset?: string;
+    defCharset?: string | undefined;
     /**
      * The maximum content length as sent (including e.g. multipart boundaries and headers)
      * @default Infinity
      */
-    maxNetworkBytes?: number;
+    maxNetworkBytes?: number | undefined;
     /**
      * The maximum content length, combining all field names, values, and files
      * @default maxNetworkBytes
      */
-    maxContentBytes?: number;
+    maxContentBytes?: number | undefined;
     /**
      * The maximum field name size (in bytes).
      * @default 100
@@ -1052,13 +1052,13 @@ interface GetFormFieldsOptions extends BusboyOptions {
      * This can be used to prevent clients uploading large files when the request has already been rejected.
      * @default 500
      */
-    closeAfterErrorDelay?: number;
+    closeAfterErrorDelay?: number | undefined;
 }
 interface GetFormDataOptions extends GetFormFieldsOptions {
     /** true to apply .trim() to all field values */
-    trimAllValues?: boolean;
+    trimAllValues?: boolean | undefined;
     /** function to apply to all uploaded files (e.g. to check available disk space) */
-    preCheckFile?: PreCheckFile;
+    preCheckFile?: PreCheckFile | undefined;
 }
 type PreCheckFile = (info: PreCheckFileInfo) => MaybePromise<PostCheckFile | void>;
 interface PreCheckFileInfo {
@@ -1091,8 +1091,8 @@ interface RangePart {
     end: number;
 }
 interface SimplifyRangeOptions {
-    forceSequential?: boolean;
-    mergeOverlapDistance?: number;
+    forceSequential?: boolean | undefined;
+    mergeOverlapDistance?: number | undefined;
 }
 declare function simplifyRange(original: HTTPRange, { forceSequential, mergeOverlapDistance }?: SimplifyRangeOptions): HTTPRange;
 
@@ -1112,7 +1112,7 @@ interface GetRangeOptions {
      *
      * @default 10
      */
-    maxRanges?: number;
+    maxRanges?: number | undefined;
     /**
      * 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).
@@ -1122,7 +1122,7 @@ interface GetRangeOptions {
      *
      * @default 2
      */
-    maxNonSequential?: number;
+    maxNonSequential?: number | undefined;
     /**
      * Maximum number of ranges a client can request in a single message if any ranges are
      * overlapping.
@@ -1132,7 +1132,7 @@ interface GetRangeOptions {
      *
      * @default 2
      */
-    maxWithOverlap?: number;
+    maxWithOverlap?: number | undefined;
 }
 declare function getRange(req: IncomingMessage, totalSize: number, { maxRanges, maxNonSequential, maxWithOverlap }?: GetRangeOptions): HTTPRange | undefined;
 interface QualityValue {
@@ -1146,7 +1146,6 @@ declare function readHTTPInteger(raw: string | undefined): number | undefined;
 declare const readHTTPQualityValues: (raw: LooseHeaderValue | 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 function getRemainingPathComponents(req: IncomingMessage, { rejectPotentiallyUnsafe }?: {
     rejectPotentiallyUnsafe?: boolean | undefined;
@@ -1166,22 +1165,22 @@ interface CSVOptions {
      * The delimiter to use between cells
      * @default ','
      */
-    delimiter?: string | Uint8Array;
+    delimiter?: string | Uint8Array | undefined;
     /**
      * The delimiter to use between rows
      * @default '\n'
      */
-    newline?: string | Uint8Array;
+    newline?: string | Uint8Array | undefined;
     /**
      * The quote character to use. Typically should be `"` or (if the target application supports it) `'`
      * @default '"'
      */
-    quote?: string;
+    quote?: string | undefined;
     /**
      * The text encoding to use.
      * @default 'utf-8'
      */
-    encoding?: BufferEncoding;
+    encoding?: BufferEncoding | undefined;
     /**
      * For use with `ServerResponse` targets.
      * If `true`, adds header=present to the mime type; if `false`, adds header=absent to the mime type.
@@ -1192,11 +1191,11 @@ interface CSVOptions {
      * If `true`, will call `end()` on target stream after writing.
      * @default true
      */
-    end?: boolean;
+    end?: boolean | undefined;
 }
 type MaybeAsyncIterable<T> = Iterable<T> | AsyncIterable<T>;
 type MaybeLoadOnDemand<T> = LoadOnDemand<T> | T;
-type CellContent = string | ReadableStream<string> | Readable | null | undefined;
+type CellContent = string | ReadableStream$1<string> | Readable | null | undefined;
 /**
  * Output a CSV formatted table, using the format from RFC4180.
  * Specifically:
@@ -1209,36 +1208,48 @@ type CellContent = string | ReadableStream<string> | Readable | null | undefined
  */
 declare function sendCSVStream(target: Writable, table: MaybeLoadOnDemand<MaybeAsyncIterable<MaybeLoadOnDemand<MaybeAsyncIterable<MaybeLoadOnDemand<CellContent>>>>>, { delimiter, newline, quote, encoding, headerRow, end, }?: CSVOptions): Promise<void>;
 
+interface EncoderOptions {
+    encodings?: ReadonlyArray<ContentEncoding> | undefined;
+    encodingQuality?: EncodingQuality | undefined;
+    estimatedLength?: number | undefined;
+    compressionSizeThreshold?: number | undefined;
+}
+declare function makeResponseEncoder(req: IncomingMessage, res: ServerResponse, { encodings, encodingQuality, estimatedLength, compressionSizeThreshold, }?: EncoderOptions): Writable;
+declare function sendEncoded(req: IncomingMessage, res: ServerResponse, content: string, options?: (EncoderOptions & {
+    encoding?: BufferEncoding | undefined;
+}) | undefined): Promise<void>;
+declare function sendEncoded(req: IncomingMessage, res: ServerResponse, content: ArrayBufferView | Readable | ReadableStream<Uint8Array>, options?: EncoderOptions | undefined): Promise<void>;
+
 declare function sendFile(req: IncomingMessage, res: ServerResponse, source: string | (Pick<ReadOnlyFileHandle, 'createReadStream'> & {
     stat?: () => Promise<Pick<Stats, 'mtimeMs' | 'size'>>;
-}) | Readable | ReadableStream<Uint8Array>, fileStats?: Pick<Stats, 'mtimeMs' | 'size'> | null, options?: GetRangeOptions & SimplifyRangeOptions): Promise<void>;
+}) | Readable | ReadableStream$1<Uint8Array>, fileStats?: Pick<Stats, 'mtimeMs' | 'size'> | null, options?: (GetRangeOptions & SimplifyRangeOptions) | undefined): Promise<void>;
 
 interface JSONOptions {
     /**
      * Either a function to invoke on every object (recursive) to be printed, or a list of properties to filter for when printing objects (applies to nested objects too).
      * @default null
      */
-    replacer?: ((this: unknown, key: string, value: unknown) => unknown) | (number | string)[] | null;
+    replacer?: ((this: unknown, key: string, value: unknown) => unknown) | ReadonlyArray<number | string> | null | undefined;
     /**
      * The amount of spacing to use for indentation. If this is 0, no spacing is used anywhere.
      * @default 0
      */
-    space?: string | number | null;
+    space?: string | number | null | undefined;
     /**
      * If the top-level value being encoded is `undefined`, setting this to `true` will output `null`. `false` will output nothing.
      * @default false
      */
-    undefinedAsNull?: boolean;
+    undefinedAsNull?: boolean | undefined;
     /**
      * The text encoding to use. Note that only Unicode variants are permitted by the standard.
      * @default 'utf-8'
      */
-    encoding?: BufferEncoding;
+    encoding?: BufferEncoding | undefined;
     /**
      * Whether to close the writable automatically after writing the JSON content.
      * @default true
      */
-    end?: boolean;
+    end?: boolean | undefined;
 }
 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>;
@@ -1250,12 +1261,12 @@ declare global {
     }
 }
 
-declare function sendRanges(req: IncomingMessage, res: ServerResponse, source: string | Pick<ReadOnlyFileHandle, 'createReadStream' | 'noRandomAccess'> | Readable | ReadableStream<Uint8Array>, httpRange: HTTPRange): Promise<void>;
+declare function sendRanges(req: IncomingMessage, res: ServerResponse, source: string | Pick<ReadOnlyFileHandle, 'createReadStream' | 'noRandomAccess'> | Readable | ReadableStream$1<Uint8Array>, httpRange: HTTPRange): Promise<void>;
 
 interface ServerSentEventsOptions {
-    keepaliveInterval?: number;
-    softCloseReconnectDelay?: number;
-    softCloseReconnectStagger?: number;
+    keepaliveInterval?: number | undefined;
+    softCloseReconnectDelay?: number | undefined;
+    softCloseReconnectStagger?: number | undefined;
 }
 interface ServerSentEvent {
     event?: string;
@@ -1269,7 +1280,7 @@ declare class ServerSentEvents {
     get open(): boolean;
     ping(): void;
     send({ event, id, data, reconnectDelay }: ServerSentEvent): Promise<void>;
-    sendFields(parts: [string, string | undefined][]): Promise<void>;
+    sendFields(parts: ReadonlyArray<[string, string | undefined]>): Promise<void>;
     close(reconnectDelay?: number, reconnectStagger?: number): Promise<void>;
 }
 
@@ -1307,7 +1318,7 @@ interface AssetServerOptions {
      *
      * @default ['etag', 'last-modified']
      */
-    dynamicHeaders?: ('etag' | 'last-modified')[] | false | undefined;
+    dynamicHeaders?: ReadonlyArray<'etag' | 'last-modified'> | false | undefined;
     /**
      * A function to call when a file is being served. Can modify headers in the response.
      *
@@ -1374,15 +1385,13 @@ interface FileServerOptions extends AssetServerOptions, FileFinderOptions {
  */
 declare const fileServer: (baseDir: string, options?: FileServerOptions) => Promise<RequestHandler<{}>>;
 
-type ContentEncoding = 'zstd' | 'br' | 'gzip' | 'deflate';
-
 interface StaticContentOptions {
     headers?: AnyHeaders | undefined;
-    encodings?: ContentEncoding[] | undefined;
-    minCompression?: number;
+    encodings?: ReadonlyArray<ContentEncoding> | undefined;
+    minCompression?: number | undefined;
 }
 declare const staticContent: (content: Buffer, contentType: string, { headers, encodings, minCompression }?: StaticContentOptions) => RequestHandler;
-declare const staticJSON: (content: unknown, options?: StaticContentOptions) => RequestHandler<{}>;
+declare const staticJSON: (content: unknown, options?: StaticContentOptions | undefined) => RequestHandler<{}>;
 
 interface InternalWebSocketServerOptions {
     noServer?: true;
@@ -1412,7 +1421,7 @@ interface ListenableWebSocket {
     on(event: 'close', handler: CloseHandler): void;
     off(event: 'message', handler: MessageHandler): void;
     off(event: 'close', handler: CloseHandler): void;
-    readyState?: number;
+    readyState?: number | undefined;
 }
 declare class WebSocketMessage {
     readonly data: Buffer;
@@ -1422,18 +1431,18 @@ declare class WebSocketMessage {
     get binary(): Buffer<ArrayBufferLike>;
 }
 interface WebSocketMessagesOptions {
-    limit?: number;
+    limit?: number | undefined;
     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>;
+    next(timeout?: number | undefined): Promise<WebSocketMessage>;
     [Symbol.asyncIterator](): AsyncIterator<WebSocketMessage, unknown, undefined>;
 }
 declare function nextWebSocketMessage(ws: ListenableWebSocket, { timeout, signal }?: {
-    timeout?: number;
-    signal?: AbortSignal;
+    timeout?: number | undefined;
+    signal?: AbortSignal | undefined;
 }): Promise<WebSocketMessage>;
 
 declare function isWebSocketRequest(req: IncomingMessage): boolean;
@@ -1449,9 +1458,9 @@ declare const getWebSocketOrigin: (req: IncomingMessage) => string | undefined;
 declare const makeWebSocketFallbackTokenFetcher: <Req>(acceptWebSocket: (req: IncomingMessage & Req) => Promise<ListenableWebSocket>, timeout?: number) => (req: IncomingMessage & Req) => Promise<string | undefined>;
 
 interface WebSocketErrorOptions {
-    message?: string;
-    closeReason?: string;
-    cause?: unknown;
+    message?: string | undefined;
+    closeReason?: string | undefined;
+    cause?: unknown | undefined;
 }
 declare class WebSocketError extends Error {
     readonly closeCode: number;
@@ -1473,9 +1482,9 @@ declare class Property<T> {
     set(req: IncomingMessage, value: T): void;
     get(req: IncomingMessage): T;
     clear(req: IncomingMessage): void;
-    withValue(value: T): RequestHandler<unknown> & UpgradeHandler<unknown>;
+    withValue(value: T): RequestHandler<{}> & UpgradeHandler<{}>;
 }
 declare const makeMemo: <T, Args extends any[] = []>(fn: (req: IncomingMessage, ...args: Args) => T, ...args: Args) => ((req: IncomingMessage) => T);
 
-export { BlockingQueue, CONTINUE, HTTPError, LoadOnDemand, NEXT_ROUTE, NEXT_ROUTER, Negotiator, PP_BASE_DENY_2026, Property, Queue, Router, STOP, ServerSentEvents, SharedFileHandle, WebListener, WebSocketError, WebSocketMessage, WebSocketMessages, ZipDirectory, ZipFile, acceptBody, acceptUpgrade, addTeardown, anyHandler, assetServer, checkIfModified, checkIfRange, compareETag, compressFileOffline, compressFilesInDir, conditionalErrorHandler, createSafeReadStream, decompressMime, defer, delegateUpgrade, dynamicFileFinder, emitError, errorHandler, fileServer, findCause, generateStrongETag, generateWeakETag, getAbortSignal, getAbsolutePath, getAddressURL, getAuthScopes, getAuthorization, getBodyJSON, getBodyStream, getBodyText, getBodyTextStream, getCharset, getFormData, getFormFields, getIfRange, getMime, getPathParameter, getPathParameters, getQuery, getRange, getRemainingPathComponents, getSearch, getSearchParams, getTextDecoder, getTextDecoderStream, getWebSocketOrigin, hasAuthScope, isSoftClosed, isWebSocketRequest, jsonErrorHandler, loadOnDemand, makeAcceptWebSocket, makeAddressTester, makeGetClient, makeMemo, makeTempFileStorage, makeWebSocketFallbackTokenFetcher, mergePermissionsPolicy, negotiateEncoding, nextWebSocketMessage, parseAddress, proxy, readHTTPDateSeconds, readHTTPInteger, readHTTPKeyValues, readHTTPQualityValues, readHTTPUnquotedCommaSeparated, readMimeTypes, readZip, registerCharset, registerMime, registerUTF32, removeForwarded, replaceForwarded, requestHandler, requireAuthScope, requireBearerAuth, resetMime, restoreAbsolutePath, sanitiseAndAppendForwarded, scheduleClose, sendCSVStream, sendFile, sendJSON, sendJSONStream, sendRanges, setSoftCloseHandler, simpleAppendForwarded, simplifyRange, staticContent, staticFileFinder, staticJSON, stringPredicate, toListeners, typedErrorHandler, upgradeHandler, willSendBody, zipFileFinder };
-export type { AcceptUpgradeHandler, AcceptUpgradeResult, Address, AnyHeaders, AssetServerOptions, AugmentedFormData, AugmentedServer, CSVOptions, CloseableReadable, CombinedServerOptions, CommonMethod, CommonUpgrade, CompressionInfo, CompressionOptions, ErrorHandler, FallbackOptions, FileFinder, FileFinderOptions, FileNegotiation, FileNegotiationOption, FileServerOptions, FormField, GetClient, GetClientOptions, GetFormDataOptions, GetFormFieldsOptions, GetRangeOptions, HTTPErrorOptions, HTTPRange, HandlerResult, JSONErrorHandlerOptions, JSONOptions, ListenOptions, ListenerOptions, NativeListeners, NegotiationOutput, NegotiationOutputHeaders, ParametersFromPath, PostCheckFile, PostCheckFileInfo, PreCheckFile, PreCheckFileInfo, ProxyChain, ProxyNode, ProxyOptions, ProxyRequestHeaderAdapter, ProxyResponseHeaderAdapter, QualityValue, RangePart, ReadOnlyFileHandle, RequestHandler, ResolvedFileInfo, ServerErrorCallback, ServerGeneralErrorCallback, ServerSentEvent, SimplifyRangeOptions, StaticContentOptions, TokenAuthHandler, UpgradeErrorHandler, UpgradeHandler, UpgradeListener, ValidPath, WithPathParameters, ZipNode };
+export { BlockingQueue, CONTINUE, HTTPError, LoadOnDemand, NEXT_ROUTE, NEXT_ROUTER, Negotiator, PP_BASE_DENY_2026, Property, Queue, Router, STOP, ServerSentEvents, SharedFileHandle, WebListener, WebSocketError, WebSocketMessage, WebSocketMessages, ZipDirectory, ZipFile, acceptBody, acceptUpgrade, addTeardown, anyHandler, assetServer, checkIfModified, checkIfRange, compareETag, compressFileOffline, compressFilesInDir, conditionalErrorHandler, createSafeReadStream, decompressMime, defer, delegateUpgrade, dynamicFileFinder, emitError, errorHandler, fileServer, findCause, generateStrongETag, generateWeakETag, getAbortSignal, getAbsolutePath, getAddressURL, getAuthScopes, getAuthorization, getBodyJSON, getBodyStream, getBodyText, getBodyTextStream, getCharset, getFormData, getFormFields, getIfRange, getMime, getPathParameter, getPathParameters, getQuery, getRange, getRemainingPathComponents, getSearch, getSearchParams, getTextDecoder, getTextDecoderStream, getWebSocketOrigin, hasAuthScope, isSoftClosed, isWebSocketRequest, jsonErrorHandler, loadOnDemand, makeAcceptWebSocket, makeAddressTester, makeGetClient, makeMemo, makeResponseEncoder, makeTempFileStorage, makeWebSocketFallbackTokenFetcher, mergePermissionsPolicy, negotiateEncoding, nextWebSocketMessage, parseAddress, proxy, readHTTPDateSeconds, readHTTPInteger, readHTTPKeyValues, readHTTPQualityValues, readHTTPUnquotedCommaSeparated, readMimeTypes, readZip, registerCharset, registerMime, registerUTF32, removeForwarded, replaceForwarded, requestHandler, requireAuthScope, requireBearerAuth, resetMime, restoreAbsolutePath, sanitiseAndAppendForwarded, scheduleClose, sendCSVStream, sendEncoded, sendFile, sendJSON, sendJSONStream, sendRanges, setSoftCloseHandler, simpleAppendForwarded, simplifyRange, staticContent, staticFileFinder, staticJSON, stringPredicate, toListeners, typedErrorHandler, upgradeHandler, willSendBody, zipFileFinder };
+export type { AcceptUpgradeHandler, AcceptUpgradeResult, Address, AnyHeaders, AssetServerOptions, AugmentedFormData, AugmentedServer, CSVOptions, CombinedServerOptions, CommonMethod, CommonUpgrade, CompressionInfo, CompressionOptions, ContentEncoding, EncoderOptions, EncodingQuality, ErrorHandler, FallbackOptions, FileFinder, FileFinderOptions, FileNegotiation, FileNegotiationOption, FileServerOptions, FormField, GetClient, GetClientOptions, GetFormDataOptions, GetFormFieldsOptions, GetRangeOptions, HTTPErrorOptions, HTTPRange, HandlerResult, JSONErrorHandlerOptions, JSONOptions, ListenOptions, ListenerOptions, NativeListeners, NegotiationOutput, NegotiationOutputHeaders, ParametersFromPath, PostCheckFile, PostCheckFileInfo, PreCheckFile, PreCheckFileInfo, ProxyChain, ProxyNode, ProxyOptions, ProxyRequestHeaderAdapter, ProxyResponseHeaderAdapter, QualityValue, RangePart, ReadOnlyFileHandle, RequestHandler, ResolvedFileInfo, ServerErrorCallback, ServerGeneralErrorCallback, ServerSentEvent, SimplifyRangeOptions, StaticContentOptions, TokenAuthHandler, UpgradeErrorHandler, UpgradeHandler, UpgradeListener, ValidPath, WithPathParameters, ZipNode };