@comapeo/map-server 1.0.0-pre.0

package/node_modules/@whatwg-node/server/esm/uwebsockets.js

@@ -0,0 +1,234 @@
+import { fakePromise } from '@whatwg-node/promise-helpers';
+export function isUWSResponse(res) {
+    return !!res.onData;
+}
+export function getRequestFromUWSRequest({ req, res, fetchAPI, controller, }) {
+    const method = req.getMethod();
+    let duplex;
+    const chunks = [];
+    const pushFns = [
+        (chunk) => {
+            chunks.push(chunk);
+        },
+    ];
+    const push = (chunk) => {
+        for (const pushFn of pushFns) {
+            pushFn(chunk);
+        }
+    };
+    let stopped = false;
+    const stopFns = [
+        () => {
+            stopped = true;
+        },
+    ];
+    const stop = () => {
+        for (const stopFn of stopFns) {
+            stopFn();
+        }
+    };
+    res.onData(function (ab, isLast) {
+        push(Buffer.from(Buffer.from(ab, 0, ab.byteLength)));
+        if (isLast) {
+            stop();
+        }
+    });
+    let getReadableStream;
+    if (method !== 'get' && method !== 'head') {
+        duplex = 'half';
+        controller.signal.addEventListener('abort', () => {
+            stop();
+        }, { once: true });
+        let readableStream;
+        getReadableStream = () => {
+            if (!readableStream) {
+                readableStream = new fetchAPI.ReadableStream({
+                    start(streamCtrl) {
+                        for (const chunk of chunks) {
+                            streamCtrl.enqueue(chunk);
+                        }
+                        if (stopped) {
+                            streamCtrl.close();
+                            return;
+                        }
+                        pushFns.push((chunk) => {
+                            streamCtrl.enqueue(chunk);
+                        });
+                        stopFns.push(() => {
+                            if (controller.signal.reason) {
+                                streamCtrl.error(controller.signal.reason);
+                                return;
+                            }
+                            if (streamCtrl.desiredSize) {
+                                streamCtrl.close();
+                            }
+                        });
+                    },
+                });
+            }
+            return readableStream;
+        };
+    }
+    const headers = new fetchAPI.Headers();
+    req.forEach((key, value) => {
+        headers.append(key, value);
+    });
+    let url = `http://localhost${req.getUrl()}`;
+    const query = req.getQuery();
+    if (query) {
+        url += `?${query}`;
+    }
+    let buffer;
+    function getBody() {
+        if (!getReadableStream) {
+            return null;
+        }
+        if (stopped) {
+            return getBufferFromChunks();
+        }
+        return getReadableStream();
+    }
+    const request = new fetchAPI.Request(url, {
+        method,
+        headers,
+        get body() {
+            return getBody();
+        },
+        signal: controller.signal,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - not in the TS types yet
+        duplex,
+    });
+    function getBufferFromChunks() {
+        if (!buffer) {
+            buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks);
+        }
+        return buffer;
+    }
+    function collectBuffer() {
+        if (stopped) {
+            return fakePromise(getBufferFromChunks());
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                stopFns.push(() => {
+                    resolve(getBufferFromChunks());
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    Object.defineProperties(request, {
+        body: {
+            get() {
+                return getBody();
+            },
+            configurable: true,
+            enumerable: true,
+        },
+        json: {
+            value() {
+                return collectBuffer()
+                    .then(b => b.toString('utf8'))
+                    .then(t => JSON.parse(t));
+            },
+            configurable: true,
+            enumerable: true,
+        },
+        text: {
+            value() {
+                return collectBuffer().then(b => b.toString('utf8'));
+            },
+            configurable: true,
+            enumerable: true,
+        },
+        arrayBuffer: {
+            value() {
+                return collectBuffer();
+            },
+            configurable: true,
+            enumerable: true,
+        },
+    });
+    return request;
+}
+export function createWritableFromUWS(uwsResponse, fetchAPI) {
+    return new fetchAPI.WritableStream({
+        write(chunk) {
+            uwsResponse.cork(() => {
+                uwsResponse.write(chunk);
+            });
+        },
+        close() {
+            uwsResponse.cork(() => {
+                uwsResponse.end();
+            });
+        },
+    });
+}
+export function sendResponseToUwsOpts(uwsResponse, fetchResponse, controller, fetchAPI) {
+    if (!fetchResponse) {
+        uwsResponse.writeStatus('404 Not Found');
+        uwsResponse.end();
+        return;
+    }
+    const bufferOfRes = fetchResponse._buffer;
+    // @ts-expect-error - Handle the case where the response is a string
+    const strBody = fetchResponse['bodyType'] === 'String' ? fetchResponse.bodyInit : undefined;
+    if (controller.signal.aborted) {
+        return;
+    }
+    uwsResponse.cork(() => {
+        uwsResponse.writeStatus(`${fetchResponse.status} ${fetchResponse.statusText}`);
+        let isSetCookieHandled = false;
+        for (const [key, value] of fetchResponse.headers) {
+            // content-length causes an error with Node.js's fetch
+            if (key !== 'content-length') {
+                if (key === 'set-cookie') {
+                    if (isSetCookieHandled) {
+                        continue;
+                    }
+                    isSetCookieHandled = true;
+                    const setCookies = fetchResponse.headers.getSetCookie?.();
+                    if (setCookies) {
+                        for (const setCookie of setCookies) {
+                            uwsResponse.writeHeader(key, setCookie);
+                        }
+                        continue;
+                    }
+                }
+                uwsResponse.writeHeader(key, value);
+            }
+        }
+        if (strBody) {
+            uwsResponse.end(strBody);
+        }
+        else if (bufferOfRes) {
+            uwsResponse.end(bufferOfRes);
+        }
+        else if (!fetchResponse.body) {
+            uwsResponse.end();
+        }
+    });
+    if (strBody || bufferOfRes || !fetchResponse.body) {
+        return;
+    }
+    controller.signal.addEventListener('abort', () => {
+        if (!fetchResponse.body?.locked) {
+            fetchResponse.body?.cancel(controller.signal.reason);
+        }
+    }, { once: true });
+    return fetchResponse.body
+        .pipeTo(createWritableFromUWS(uwsResponse, fetchAPI), {
+        signal: controller.signal,
+    })
+        .catch(err => {
+        if (controller.signal.aborted) {
+            return;
+        }
+        throw err;
+    });
+}
+export { fakePromise };

package/node_modules/@whatwg-node/server/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@whatwg-node/server",
+  "version": "0.10.17",
+  "description": "Fetch API compliant HTTP Server adapter",
+  "sideEffects": false,
+  "dependencies": {
+    "@envelop/instrumentation": "^1.0.0",
+    "@whatwg-node/disposablestack": "^0.0.6",
+    "@whatwg-node/promise-helpers": "^1.3.2",
+    "tslib": "^2.6.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "ardatan/whatwg-node",
+    "directory": "packages/server"
+  },
+  "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

package/node_modules/@whatwg-node/server/typings/createServerAdapter.d.cts

@@ -0,0 +1,19 @@
+import { ServerAdapterPlugin } from './plugins/types.cjs';
+import { FetchAPI, ServerAdapter, ServerAdapterBaseObject, ServerAdapterRequestHandler } from './types.cjs';
+export interface ServerAdapterOptions<TServerContext> {
+    plugins?: ServerAdapterPlugin<TServerContext>[];
+    fetchAPI?: Partial<FetchAPI>;
+    /**
+     * Node.js only!
+     *
+     * If true, the server adapter will dispose itself when the process is terminated.
+     * If false, you have to dispose the server adapter by using the `dispose` method,
+     * or [Explicit Resource Management](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html)
+     */
+    disposeOnProcessTerminate?: boolean;
+    __useCustomAbortCtrl?: boolean;
+    __useSingleWriteHead?: boolean;
+}
+declare function createServerAdapter<TServerContext = {}, THandleRequest extends ServerAdapterRequestHandler<TServerContext> = ServerAdapterRequestHandler<TServerContext>>(serverAdapterRequestHandler: THandleRequest, options?: ServerAdapterOptions<TServerContext>): ServerAdapter<TServerContext, ServerAdapterBaseObject<TServerContext, THandleRequest>>;
+declare function createServerAdapter<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext>>(serverAdapterBaseObject: TBaseObject, options?: ServerAdapterOptions<TServerContext>): ServerAdapter<TServerContext, TBaseObject>;
+export { createServerAdapter };

package/node_modules/@whatwg-node/server/typings/createServerAdapter.d.ts

@@ -0,0 +1,19 @@
+import { ServerAdapterPlugin } from './plugins/types.js';
+import { FetchAPI, ServerAdapter, ServerAdapterBaseObject, ServerAdapterRequestHandler } from './types.js';
+export interface ServerAdapterOptions<TServerContext> {
+    plugins?: ServerAdapterPlugin<TServerContext>[];
+    fetchAPI?: Partial<FetchAPI>;
+    /**
+     * Node.js only!
+     *
+     * If true, the server adapter will dispose itself when the process is terminated.
+     * If false, you have to dispose the server adapter by using the `dispose` method,
+     * or [Explicit Resource Management](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html)
+     */
+    disposeOnProcessTerminate?: boolean;
+    __useCustomAbortCtrl?: boolean;
+    __useSingleWriteHead?: boolean;
+}
+declare function createServerAdapter<TServerContext = {}, THandleRequest extends ServerAdapterRequestHandler<TServerContext> = ServerAdapterRequestHandler<TServerContext>>(serverAdapterRequestHandler: THandleRequest, options?: ServerAdapterOptions<TServerContext>): ServerAdapter<TServerContext, ServerAdapterBaseObject<TServerContext, THandleRequest>>;
+declare function createServerAdapter<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext>>(serverAdapterBaseObject: TBaseObject, options?: ServerAdapterOptions<TServerContext>): ServerAdapter<TServerContext, TBaseObject>;
+export { createServerAdapter };

package/node_modules/@whatwg-node/server/typings/index.d.cts

@@ -0,0 +1,11 @@
+export * from './createServerAdapter.cjs';
+export * from './types.cjs';
+export * from './utils.cjs';
+export * from './plugins/types.cjs';
+export * from './plugins/useCors.cjs';
+export * from './plugins/useErrorHandling.cjs';
+export * from './plugins/useContentEncoding.cjs';
+export * from './uwebsockets.cjs';
+export { Response } from '@whatwg-node/fetch';
+export { DisposableSymbols } from '@whatwg-node/disposablestack';
+export * from '@envelop/instrumentation';

package/node_modules/@whatwg-node/server/typings/index.d.ts

@@ -0,0 +1,11 @@
+export * from './createServerAdapter.js';
+export * from './types.js';
+export * from './utils.js';
+export * from './plugins/types.js';
+export * from './plugins/useCors.js';
+export * from './plugins/useErrorHandling.js';
+export * from './plugins/useContentEncoding.js';
+export * from './uwebsockets.js';
+export { Response } from '@whatwg-node/fetch';
+export { DisposableSymbols } from '@whatwg-node/disposablestack';
+export * from '@envelop/instrumentation';

package/node_modules/@whatwg-node/server/typings/plugins/types.d.cts

@@ -0,0 +1,76 @@
+import { FetchAPI, ServerAdapterRequestHandler, type ServerAdapterInitialContext } from '../types.cjs';
+export interface ServerAdapterPlugin<TServerContext = {}> {
+    /**
+     * A tracer instance. It can be used to wrap the entire request handling pipeline (including the
+     * plugin hooks). It is mostly used for observability (monitoring, tracing, etc...).
+     */
+    instrumentation?: Instrumentation;
+    /**
+     * This hook is invoked for ANY incoming HTTP request. Here you can manipulate the request,
+     * create a short circuit before the request handler takes it over.
+     *
+     * Warning: Exceptions thrown by this hook are not caught.
+     * This means they will buble up to the HTTP server underlying implementation.
+     * For example, the `node:http` server crashes the entire process on uncaught exceptions.
+     */
+    onRequest?: OnRequestHook<TServerContext & ServerAdapterInitialContext>;
+    /**
+     * This hook is invoked after a HTTP request (both GraphQL and NON GraphQL) has been processed
+     * and after the response has been forwarded to the client. Here you can perform any cleanup
+     * or logging operations, or you can manipulate the outgoing response object.
+     *
+     * Warning: Exceptions thrown by this hook are not caught.
+     * This means they will buble up to the HTTP server underlying implementation.
+     * For example, the `node:http` server crashes the entire process on uncaught exceptions.
+     */
+    onResponse?: OnResponseHook<TServerContext & ServerAdapterInitialContext>;
+    /**
+     * This hook is invoked when the server is being disposed.
+     * The server disposal is triggered either by the process termination or the explicit server disposal.
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
+     */
+    [Symbol.dispose]?: () => void;
+    /**
+     * This hook is invoked when the server is being disposed.
+     * The server disposal is triggered either by the process termination or the explicit server disposal.
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
+     */
+    [Symbol.asyncDispose]?: () => PromiseLike<void> | void;
+    /**
+     * This hook is invoked when the server is being disposed.
+     * The server disposal is triggered either by the process termination or the explicit server disposal.
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
+     */
+    onDispose?: () => PromiseLike<void> | void;
+}
+export type Instrumentation = {
+    /**
+     * Run code befor, after or around the handling of each request.
+     * This instrument can't modify result or paramters of the request handling.
+     * To have access to the input or the output of the request handling, use the `onRequest` hook.
+     *
+     * Note: The `wrapped` function must be called, otherwise the request will not be handled properly
+     */
+    request?: (payload: {
+        request: Request;
+    }, wrapped: () => Promise<void> | void) => Promise<void> | void;
+};
+export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
+export interface OnRequestEventPayload<TServerContext> {
+    request: Request;
+    setRequest(newRequest: Request): void;
+    serverContext: TServerContext;
+    fetchAPI: FetchAPI;
+    requestHandler: ServerAdapterRequestHandler<TServerContext>;
+    setRequestHandler(newRequestHandler: ServerAdapterRequestHandler<TServerContext>): void;
+    endResponse(response: Response): void;
+    url: URL;
+}
+export type OnResponseHook<TServerContext> = (payload: OnResponseEventPayload<TServerContext>) => Promise<void> | void;
+export interface OnResponseEventPayload<TServerContext> {
+    request: Request;
+    serverContext: TServerContext;
+    response: Response;
+    setResponse(newResponse: Response): void;
+    fetchAPI: FetchAPI;
+}

package/node_modules/@whatwg-node/server/typings/plugins/types.d.ts

@@ -0,0 +1,76 @@
+import { FetchAPI, ServerAdapterRequestHandler, type ServerAdapterInitialContext } from '../types.js';
+export interface ServerAdapterPlugin<TServerContext = {}> {
+    /**
+     * A tracer instance. It can be used to wrap the entire request handling pipeline (including the
+     * plugin hooks). It is mostly used for observability (monitoring, tracing, etc...).
+     */
+    instrumentation?: Instrumentation;
+    /**
+     * This hook is invoked for ANY incoming HTTP request. Here you can manipulate the request,
+     * create a short circuit before the request handler takes it over.
+     *
+     * Warning: Exceptions thrown by this hook are not caught.
+     * This means they will buble up to the HTTP server underlying implementation.
+     * For example, the `node:http` server crashes the entire process on uncaught exceptions.
+     */
+    onRequest?: OnRequestHook<TServerContext & ServerAdapterInitialContext>;
+    /**
+     * This hook is invoked after a HTTP request (both GraphQL and NON GraphQL) has been processed
+     * and after the response has been forwarded to the client. Here you can perform any cleanup
+     * or logging operations, or you can manipulate the outgoing response object.
+     *
+     * Warning: Exceptions thrown by this hook are not caught.
+     * This means they will buble up to the HTTP server underlying implementation.
+     * For example, the `node:http` server crashes the entire process on uncaught exceptions.
+     */
+    onResponse?: OnResponseHook<TServerContext & ServerAdapterInitialContext>;
+    /**
+     * This hook is invoked when the server is being disposed.
+     * The server disposal is triggered either by the process termination or the explicit server disposal.
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
+     */
+    [Symbol.dispose]?: () => void;
+    /**
+     * This hook is invoked when the server is being disposed.
+     * The server disposal is triggered either by the process termination or the explicit server disposal.
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
+     */
+    [Symbol.asyncDispose]?: () => PromiseLike<void> | void;
+    /**
+     * This hook is invoked when the server is being disposed.
+     * The server disposal is triggered either by the process termination or the explicit server disposal.
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
+     */
+    onDispose?: () => PromiseLike<void> | void;
+}
+export type Instrumentation = {
+    /**
+     * Run code befor, after or around the handling of each request.
+     * This instrument can't modify result or paramters of the request handling.
+     * To have access to the input or the output of the request handling, use the `onRequest` hook.
+     *
+     * Note: The `wrapped` function must be called, otherwise the request will not be handled properly
+     */
+    request?: (payload: {
+        request: Request;
+    }, wrapped: () => Promise<void> | void) => Promise<void> | void;
+};
+export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
+export interface OnRequestEventPayload<TServerContext> {
+    request: Request;
+    setRequest(newRequest: Request): void;
+    serverContext: TServerContext;
+    fetchAPI: FetchAPI;
+    requestHandler: ServerAdapterRequestHandler<TServerContext>;
+    setRequestHandler(newRequestHandler: ServerAdapterRequestHandler<TServerContext>): void;
+    endResponse(response: Response): void;
+    url: URL;
+}
+export type OnResponseHook<TServerContext> = (payload: OnResponseEventPayload<TServerContext>) => Promise<void> | void;
+export interface OnResponseEventPayload<TServerContext> {
+    request: Request;
+    serverContext: TServerContext;
+    response: Response;
+    setResponse(newResponse: Response): void;
+    fetchAPI: FetchAPI;
+}

package/node_modules/@whatwg-node/server/typings/plugins/useContentEncoding.d.cts

@@ -0,0 +1,2 @@
+import type { ServerAdapterPlugin } from './types.cjs';
+export declare function useContentEncoding<TServerContext>(): ServerAdapterPlugin<TServerContext>;

package/node_modules/@whatwg-node/server/typings/plugins/useContentEncoding.d.ts

@@ -0,0 +1,2 @@
+import type { ServerAdapterPlugin } from './types.js';
+export declare function useContentEncoding<TServerContext>(): ServerAdapterPlugin<TServerContext>;

package/node_modules/@whatwg-node/server/typings/plugins/useCors.d.cts

@@ -0,0 +1,14 @@
+import { MaybePromise } from '@whatwg-node/promise-helpers';
+import type { ServerAdapterPlugin } from './types.cjs';
+export type CORSOptions = {
+    origin?: string[] | string;
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+} | false;
+export type CORSPluginOptions<TServerContext> = CORSOptionsFactory<TServerContext> | CORSOptions | boolean;
+export type CORSOptionsFactory<TServerContext> = (request: Request, ...args: {} extends TServerContext ? [serverContext?: TServerContext | undefined] : [serverContext: TServerContext]) => MaybePromise<CORSOptions>;
+export declare function getCORSHeadersByRequestAndOptions(request: Request, corsOptions: CORSOptions): Record<string, string> | null;
+export declare function useCORS<TServerContext>(options?: CORSPluginOptions<TServerContext>): ServerAdapterPlugin<TServerContext>;

package/node_modules/@whatwg-node/server/typings/plugins/useCors.d.ts

@@ -0,0 +1,14 @@
+import { MaybePromise } from '@whatwg-node/promise-helpers';
+import type { ServerAdapterPlugin } from './types.js';
+export type CORSOptions = {
+    origin?: string[] | string;
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+} | false;
+export type CORSPluginOptions<TServerContext> = CORSOptionsFactory<TServerContext> | CORSOptions | boolean;
+export type CORSOptionsFactory<TServerContext> = (request: Request, ...args: {} extends TServerContext ? [serverContext?: TServerContext | undefined] : [serverContext: TServerContext]) => MaybePromise<CORSOptions>;
+export declare function getCORSHeadersByRequestAndOptions(request: Request, corsOptions: CORSOptions): Record<string, string> | null;
+export declare function useCORS<TServerContext>(options?: CORSPluginOptions<TServerContext>): ServerAdapterPlugin<TServerContext>;

package/node_modules/@whatwg-node/server/typings/plugins/useErrorHandling.d.cts

@@ -0,0 +1,13 @@
+import { MaybePromise } from '@whatwg-node/promise-helpers';
+import type { ServerAdapterPlugin } from './types.cjs';
+export declare function createDefaultErrorHandler<TServerContext = {}>(ResponseCtor?: typeof Response): ErrorHandler<TServerContext>;
+export declare class HTTPError extends Error {
+    status: number;
+    message: string;
+    headers: HeadersInit;
+    details?: any | undefined;
+    name: string;
+    constructor(status: number | undefined, message: string, headers?: HeadersInit, details?: any | undefined);
+}
+export type ErrorHandler<TServerContext> = (e: any, request: Request, ctx: TServerContext) => MaybePromise<Response> | void;
+export declare function useErrorHandling<TServerContext>(onError?: ErrorHandler<TServerContext>): ServerAdapterPlugin<TServerContext>;

package/node_modules/@whatwg-node/server/typings/plugins/useErrorHandling.d.ts

@@ -0,0 +1,13 @@
+import { MaybePromise } from '@whatwg-node/promise-helpers';
+import type { ServerAdapterPlugin } from './types.js';
+export declare function createDefaultErrorHandler<TServerContext = {}>(ResponseCtor?: typeof Response): ErrorHandler<TServerContext>;
+export declare class HTTPError extends Error {
+    status: number;
+    message: string;
+    headers: HeadersInit;
+    details?: any | undefined;
+    name: string;
+    constructor(status: number | undefined, message: string, headers?: HeadersInit, details?: any | undefined);
+}
+export type ErrorHandler<TServerContext> = (e: any, request: Request, ctx: TServerContext) => MaybePromise<Response> | void;
+export declare function useErrorHandling<TServerContext>(onError?: ErrorHandler<TServerContext>): ServerAdapterPlugin<TServerContext>;

package/node_modules/@whatwg-node/server/typings/types.d.cts

@@ -0,0 +1,100 @@
+import type { RequestListener } from 'node:http';
+import type { MaybePromise, MaybePromiseLike } from '@whatwg-node/promise-helpers';
+import type { NodeRequest, NodeResponse } from './utils.cjs';
+import { UWSHandler, UWSRequest, UWSResponse } from './uwebsockets.cjs';
+export interface FetchEvent extends Event {
+    waitUntil(f: MaybePromise<void>): void;
+    request: Request;
+    respondWith(r: MaybePromiseLike<Response>): void;
+}
+export interface ServerAdapterBaseObject<TServerContext, THandleRequest extends ServerAdapterRequestHandler<TServerContext> = ServerAdapterRequestHandler<TServerContext>> {
+    /**
+     * An async function that takes `Request` and the server context and returns a `Response`.
+     * If you use `requestListener`, the server context is `{ req: IncomingMessage, res: ServerResponse }`.
+     */
+    handle: THandleRequest;
+}
+export interface ServerAdapterObject<TServerContext> extends EventListenerObject, AsyncDisposable {
+    /**
+     * A basic request listener that takes a `Request` with the server context and returns a `Response`.
+     */
+    handleRequest: (request: Request, ctx: TServerContext & Partial<ServerAdapterInitialContext>) => MaybePromise<Response>;
+    /**
+     * WHATWG Fetch spec compliant `fetch` function that can be used for testing purposes.
+     */
+    fetch(request: Request, ctx: TServerContext): MaybePromise<Response>;
+    fetch(request: Request, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+    fetch(urlStr: string, ctx: TServerContext): MaybePromise<Response>;
+    fetch(urlStr: string, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+    fetch(urlStr: string, init: RequestInit, ctx: TServerContext): MaybePromise<Response>;
+    fetch(urlStr: string, init: RequestInit, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+    fetch(url: URL, ctx: TServerContext): MaybePromise<Response>;
+    fetch(url: URL, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+    fetch(url: URL, init: RequestInit, ctx: TServerContext): MaybePromise<Response>;
+    fetch(url: URL, init: RequestInit, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+    /**
+     * This function takes Node's request object and returns a WHATWG Fetch spec compliant `Response` object.
+     *
+     * @deprecated Use `handleNodeRequestAndResponse` instead.
+     **/
+    handleNodeRequest(nodeRequest: NodeRequest, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+    /**
+     * This function takes Node's request and response objects and returns a WHATWG Fetch spec compliant `Response` object.
+     */
+    handleNodeRequestAndResponse(nodeRequest: NodeRequest, nodeResponseOrContainer: {
+        raw: NodeResponse;
+    } | NodeResponse, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+    /**
+     * A request listener function that can be used with any Node server variation.
+     */
+    requestListener: RequestListener;
+    handleUWS: UWSHandler;
+    handle(req: NodeRequest, res: NodeResponse, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<void>;
+    handle(requestLike: RequestLike, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+    handle(request: Request, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+    handle(request: Request, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+    handle(fetchEvent: FetchEvent & Partial<TServerContext & ServerAdapterInitialContext>, ...ctx: Partial<TServerContext>[]): void;
+    handle(res: UWSResponse, req: UWSRequest, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<void>;
+    handle(container: {
+        request: Request;
+    } & Partial<TServerContext & ServerAdapterInitialContext>, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+    disposableStack: AsyncDisposableStack;
+    dispose(): Promise<void> | void;
+    /**
+     * Register a promise that should be waited in the background for before the server process is exited.
+     *
+     * This also avoids unhandled promise rejections, which would otherwise cause the process to exit on some environment like Node.
+     * @param promise The promise to wait for
+     * @returns
+     */
+    waitUntil: WaitUntilFn;
+}
+export interface RequestLike {
+    url: string;
+    method: string;
+    headers: HeadersLike;
+    body?: AsyncIterable<Uint8Array> | null;
+}
+export interface HeadersLike extends Iterable<[string, string]> {
+    get(name: string): string | null | undefined;
+    set(name: string, value: string): void;
+    has(name: string): boolean;
+}
+export type ServerAdapter<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext>> = TBaseObject & ServerAdapterObject<TServerContext>['handle'] & ServerAdapterObject<TServerContext>;
+export type ServerAdapterRequestHandler<TServerContext> = (request: Request, ctx: TServerContext & ServerAdapterInitialContext) => MaybePromise<Response>;
+export type ServerAdapterNodeContext = {
+    req: NodeRequest;
+    res: NodeResponse;
+};
+export type WaitUntilFn = (promise: Promise<void> | void) => void;
+export type FetchAPI = ReturnType<typeof import('@whatwg-node/fetch').createFetch>;
+export type ServerAdapterInitialContext = {
+    /**
+     * Register a promise that should be waited in the background for before the server process is exited.
+     *
+     * This also avoids unhandled promise rejections, which would otherwise cause the process to exit on some environment like Node.
+     * @param promise The promise to wait for
+     * @returns
+     */
+    waitUntil: WaitUntilFn;
+};