@hasna/connectors 1.3.31 → 1.3.33

package/connectors/connect-imessage/node_modules/bun-types/serve.d.ts

@@ -1,1296 +0,0 @@
-declare module "bun" {
-  /**
-   * A status that represents the outcome of a sent message.
-   *
-   * - if **0**, the message was **dropped**.
-   * - if **-1**, there is **backpressure** of messages.
-   * - if **>0**, it represents the **number of bytes sent**.
-   *
-   * @example
-   * ```js
-   * const status = ws.send("Hello!");
-   * if (status === 0) {
-   *   console.log("Message was dropped");
-   * } else if (status === -1) {
-   *   console.log("Backpressure was applied");
-   * } else {
-   *   console.log(`Success! Sent ${status} bytes`);
-   * }
-   * ```
-   */
-  type ServerWebSocketSendStatus = number;
-
-  /**
-   * A state that represents if a WebSocket is connected.
-   *
-   * - `WebSocket.CONNECTING` is `0`, the connection is pending.
-   * - `WebSocket.OPEN` is `1`, the connection is established and `send()` is possible.
-   * - `WebSocket.CLOSING` is `2`, the connection is closing.
-   * - `WebSocket.CLOSED` is `3`, the connection is closed or couldn't be opened.
-   *
-   * @link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/readyState
-   */
-  type WebSocketReadyState = 0 | 1 | 2 | 3;
-
-  /**
-   * A fast WebSocket designed for servers.
-   *
-   * Features:
-   * - **Message compression** - Messages can be compressed
-   * - **Backpressure** - If the client is not ready to receive data, the server will tell you.
-   * - **Dropped messages** - If the client cannot receive data, the server will tell you.
-   * - **Topics** - Messages can be {@link ServerWebSocket.publish}ed to a specific topic and the client can {@link ServerWebSocket.subscribe} to topics
-   *
-   * This is slightly different than the browser {@link WebSocket} which Bun supports for clients.
-   *
-   * Powered by [uWebSockets](https://github.com/uNetworking/uWebSockets).
-   *
-   * @example
-   * ```ts
-   * Bun.serve({
-   *   websocket: {
-   *     open(ws) {
-   *       console.log("Connected", ws.remoteAddress);
-   *     },
-   *     message(ws, data) {
-   *       console.log("Received", data);
-   *       ws.send(data);
-   *     },
-   *     close(ws, code, reason) {
-   *       console.log("Disconnected", code, reason);
-   *     },
-   *   }
-   * });
-   * ```
-   */
-  interface ServerWebSocket<T = undefined> {
-    /**
-     * Sends a message to the client.
-     *
-     * @param data The data to send.
-     * @param compress Should the data be compressed? If the client does not support compression, this is ignored.
-     * @example
-     * ws.send("Hello!");
-     * ws.send("Compress this.", true);
-     * ws.send(new Uint8Array([1, 2, 3, 4]));
-     */
-    send(data: string | BufferSource, compress?: boolean): ServerWebSocketSendStatus;
-
-    /**
-     * Sends a text message to the client.
-     *
-     * @param data The data to send.
-     * @param compress Should the data be compressed? If the client does not support compression, this is ignored.
-     * @example
-     * ws.send("Hello!");
-     * ws.send("Compress this.", true);
-     */
-    sendText(data: string, compress?: boolean): ServerWebSocketSendStatus;
-
-    /**
-     * Sends a binary message to the client.
-     *
-     * @param data The data to send.
-     * @param compress Should the data be compressed? If the client does not support compression, this is ignored.
-     * @example
-     * ws.send(new TextEncoder().encode("Hello!"));
-     * ws.send(new Uint8Array([1, 2, 3, 4]), true);
-     */
-    sendBinary(data: BufferSource, compress?: boolean): ServerWebSocketSendStatus;
-
-    /**
-     * Closes the connection.
-     *
-     * Here is a list of close codes:
-     * - `1000` means "normal closure" **(default)**
-     * - `1009` means a message was too big and was rejected
-     * - `1011` means the server encountered an error
-     * - `1012` means the server is restarting
-     * - `1013` means the server is too busy or the client is rate-limited
-     * - `4000` through `4999` are reserved for applications (you can use it!)
-     *
-     * To close the connection abruptly, use `terminate()`.
-     *
-     * @param code The close code to send
-     * @param reason The close reason to send
-     */
-    close(code?: number, reason?: string): void;
-
-    /**
-     * Abruptly close the connection.
-     *
-     * To gracefully close the connection, use `close()`.
-     */
-    terminate(): void;
-
-    /**
-     * Sends a ping.
-     *
-     * @param data The data to send
-     */
-    ping(data?: string | BufferSource): ServerWebSocketSendStatus;
-
-    /**
-     * Sends a pong.
-     *
-     * @param data The data to send
-     */
-    pong(data?: string | BufferSource): ServerWebSocketSendStatus;
-
-    /**
-     * Sends a message to subscribers of the topic.
-     *
-     * @param topic The topic name.
-     * @param data The data to send.
-     * @param compress Should the data be compressed? If the client does not support compression, this is ignored.
-     * @example
-     * ws.publish("chat", "Hello!");
-     * ws.publish("chat", "Compress this.", true);
-     * ws.publish("chat", new Uint8Array([1, 2, 3, 4]));
-     */
-    publish(topic: string, data: string | BufferSource, compress?: boolean): ServerWebSocketSendStatus;
-
-    /**
-     * Sends a text message to subscribers of the topic.
-     *
-     * @param topic The topic name.
-     * @param data The data to send.
-     * @param compress Should the data be compressed? If the client does not support compression, this is ignored.
-     * @example
-     * ws.publish("chat", "Hello!");
-     * ws.publish("chat", "Compress this.", true);
-     */
-    publishText(topic: string, data: string, compress?: boolean): ServerWebSocketSendStatus;
-
-    /**
-     * Sends a binary message to subscribers of the topic.
-     *
-     * @param topic The topic name.
-     * @param data The data to send.
-     * @param compress Should the data be compressed? If the client does not support compression, this is ignored.
-     * @example
-     * ws.publish("chat", new TextEncoder().encode("Hello!"));
-     * ws.publish("chat", new Uint8Array([1, 2, 3, 4]), true);
-     */
-    publishBinary(topic: string, data: BufferSource, compress?: boolean): ServerWebSocketSendStatus;
-
-    /**
-     * Subscribes a client to the topic.
-     *
-     * @param topic The topic name.
-     * @example
-     * ws.subscribe("chat");
-     */
-    subscribe(topic: string): void;
-
-    /**
-     * Unsubscribes a client to the topic.
-     *
-     * @param topic The topic name.
-     * @example
-     * ws.unsubscribe("chat");
-     */
-    unsubscribe(topic: string): void;
-
-    /**
-     * Is the client subscribed to a topic?
-     *
-     * @param topic The topic name.
-     * @example
-     * ws.subscribe("chat");
-     * console.log(ws.isSubscribed("chat")); // true
-     */
-    isSubscribed(topic: string): boolean;
-
-    /**
-     * Returns an array of all topics the client is currently subscribed to.
-     *
-     * @example
-     * ws.subscribe("chat");
-     * ws.subscribe("notifications");
-     * console.log(ws.subscriptions); // ["chat", "notifications"]
-     */
-    readonly subscriptions: string[];
-
-    /**
-     * Batches `send()` and `publish()` operations, which makes it faster to send data.
-     *
-     * The `message`, `open`, and `drain` callbacks are automatically corked, so
-     * you only need to call this if you are sending messages outside of those
-     * callbacks or in async functions.
-     *
-     * @param callback The callback to run.
-     * @example
-     * ws.cork((ctx) => {
-     *   ctx.send("These messages");
-     *   ctx.sendText("are sent");
-     *   ctx.sendBinary(new TextEncoder().encode("together!"));
-     * });
-     */
-    cork<T = unknown>(callback: (ws: ServerWebSocket<T>) => T): T;
-
-    /**
-     * The IP address of the client.
-     *
-     * @example
-     * console.log(socket.remoteAddress); // "127.0.0.1"
-     */
-    readonly remoteAddress: string;
-
-    /**
-     * The ready state of the client.
-     *
-     * - if `0`, the client is connecting.
-     * - if `1`, the client is connected.
-     * - if `2`, the client is closing.
-     * - if `3`, the client is closed.
-     *
-     * @example
-     * console.log(socket.readyState); // 1
-     */
-    readonly readyState: WebSocketReadyState;
-
-    /**
-     * Sets how binary data is returned in events.
-     *
-     * - if `nodebuffer`, binary data is returned as `Buffer` objects. **(default)**
-     * - if `arraybuffer`, binary data is returned as `ArrayBuffer` objects.
-     * - if `uint8array`, binary data is returned as `Uint8Array` objects.
-     *
-     * @example
-     * let ws: WebSocket;
-     * ws.binaryType = "uint8array";
-     * ws.addEventListener("message", ({ data }) => {
-     *   console.log(data instanceof Uint8Array); // true
-     * });
-     */
-    binaryType?: "nodebuffer" | "arraybuffer" | "uint8array";
-
-    /**
-     * Custom data that you can assign to a client, can be read and written at any time.
-     *
-     * @example
-     * import { serve } from "bun";
-     *
-     * serve({
-     *   fetch(request, server) {
-     *     const data = {
-     *       accessToken: request.headers.get("Authorization"),
-     *     };
-     *     if (server.upgrade(request, { data })) {
-     *       return;
-     *     }
-     *     return new Response();
-     *   },
-     *   websocket: {
-     *     data: {} as {accessToken: string | null},
-     *     message(ws) {
-     *       console.log(ws.data.accessToken);
-     *     }
-     *   }
-     * });
-     */
-    data: T;
-
-    getBufferedAmount(): number;
-  }
-
-  /**
-   * Compression options for WebSocket messages.
-   */
-  type WebSocketCompressor =
-    | "disable"
-    | "shared"
-    | "dedicated"
-    | "3KB"
-    | "4KB"
-    | "8KB"
-    | "16KB"
-    | "32KB"
-    | "64KB"
-    | "128KB"
-    | "256KB";
-
-  /**
-   * Create a server-side {@link ServerWebSocket} handler for use with {@link Bun.serve}
-   *
-   * @example
-   * ```ts
-   * import { websocket, serve } from "bun";
-   *
-   * serve<{name: string}>({
-   *   port: 3000,
-   *   websocket: {
-   *     open: (ws) => {
-   *       console.log("Client connected");
-   *    },
-   *     message: (ws, message) => {
-   *       console.log(`${ws.data.name}: ${message}`);
-   *    },
-   *     close: (ws) => {
-   *       console.log("Client disconnected");
-   *    },
-   *  },
-   *
-   *   fetch(req, server) {
-   *     const url = new URL(req.url);
-   *     if (url.pathname === "/chat") {
-   *       const upgraded = server.upgrade(req, {
-   *         data: {
-   *           name: new URL(req.url).searchParams.get("name"),
-   *        },
-   *      });
-   *       if (!upgraded) {
-   *         return new Response("Upgrade failed", { status: 400 });
-   *      }
-   *      return;
-   *    }
-   *     return new Response("Hello World");
-   *  },
-   * });
-   * ```
-   */
-  interface WebSocketHandler<T> {
-    /**
-     * Specify the type for the {@link ServerWebSocket.data} property on
-     * connecting websocket clients. You can pass this value when you make a
-     * call to {@link Server.upgrade}.
-     *
-     * This pattern exists in Bun due to a [TypeScript limitation (#26242)](https://github.com/microsoft/TypeScript/issues/26242)
-     *
-     * @example
-     * ```ts
-     * Bun.serve({
-     *   websocket: {
-     *     data: {} as { name: string }, // ← Specify the type of `ws.data` like this
-     *     message: (ws, message) => console.log(ws.data.name, 'says:', message);
-     *   },
-     *   // ...
-     * });
-     * ```
-     */
-    data?: T;
-
-    /**
-     * Called when the server receives an incoming message.
-     *
-     * If the message is not a `string`, its type is based on the value of `binaryType`.
-     * - if `nodebuffer`, then the message is a `Buffer`.
-     * - if `arraybuffer`, then the message is an `ArrayBuffer`.
-     * - if `uint8array`, then the message is a `Uint8Array`.
-     *
-     * @param ws The websocket that sent the message
-     * @param message The message received
-     */
-    message(ws: ServerWebSocket<T>, message: string | Buffer<ArrayBuffer>): void | Promise<void>;
-
-    /**
-     * Called when a connection is opened.
-     *
-     * @param ws The websocket that was opened
-     */
-    open?(ws: ServerWebSocket<T>): void | Promise<void>;
-
-    /**
-     * Called when a connection was previously under backpressure,
-     * meaning it had too many queued messages, but is now ready to receive more data.
-     *
-     * @param ws The websocket that is ready for more data
-     */
-    drain?(ws: ServerWebSocket<T>): void | Promise<void>;
-
-    /**
-     * Called when a connection is closed.
-     *
-     * @param ws The websocket that was closed
-     * @param code The close code
-     * @param reason The close reason
-     */
-    close?(ws: ServerWebSocket<T>, code: number, reason: string): void | Promise<void>;
-
-    /**
-     * Called when a ping is sent.
-     *
-     * @param ws The websocket that received the ping
-     * @param data The data sent with the ping
-     */
-    ping?(ws: ServerWebSocket<T>, data: Buffer): void | Promise<void>;
-
-    /**
-     * Called when a pong is received.
-     *
-     * @param ws The websocket that received the ping
-     * @param data The data sent with the ping
-     */
-    pong?(ws: ServerWebSocket<T>, data: Buffer): void | Promise<void>;
-
-    /**
-     * Sets the maximum size of messages in bytes.
-     *
-     * Default is 16 MB, or `1024 * 1024 * 16` in bytes.
-     */
-    maxPayloadLength?: number;
-
-    /**
-     * Sets the maximum number of bytes that can be buffered on a single connection.
-     *
-     * Default is 16 MB, or `1024 * 1024 * 16` in bytes.
-     */
-    backpressureLimit?: number;
-
-    /**
-     * Sets if the connection should be closed if `backpressureLimit` is reached.
-     *
-     * @default false
-     */
-    closeOnBackpressureLimit?: boolean;
-
-    /**
-     * Sets the number of seconds to wait before timing out a connection
-     * due to no messages or pings.
-     *
-     * @default 120
-     */
-    idleTimeout?: number;
-
-    /**
-     * Should `ws.publish()` also send a message to `ws` (itself), if it is subscribed?
-     *
-     * @default false
-     */
-    publishToSelf?: boolean;
-
-    /**
-     * Should the server automatically send and respond to pings to clients?
-     *
-     * @default true
-     */
-    sendPings?: boolean;
-
-    /**
-     * Sets the compression level for messages, for clients that supports it. By default, compression is disabled.
-     *
-     * @default false
-     */
-    perMessageDeflate?:
-      | boolean
-      | {
-          /**
-           * Sets the compression level.
-           */
-          compress?: WebSocketCompressor | boolean;
-          /**
-           * Sets the decompression level.
-           */
-          decompress?: WebSocketCompressor | boolean;
-        };
-  }
-
-  namespace Serve {
-    type ExtractRouteParams<T> = string extends T
-      ? Record<string, string>
-      : T extends `${string}:${infer Param}/${infer Rest}`
-        ? { [K in Param]: string } & ExtractRouteParams<Rest>
-        : T extends `${string}:${infer Param}`
-          ? { [K in Param]: string }
-          : T extends `${string}*`
-            ? {}
-            : {};
-
-    /**
-     * Development configuration for {@link Bun.serve}
-     */
-    type Development =
-      | boolean
-      | {
-          /**
-           * Enable Hot Module Replacement for routes (including React Fast Refresh, if React is in use)
-           *
-           * @default true if process.env.NODE_ENV !== 'production'
-           *
-           */
-          hmr?: boolean;
-
-          /**
-           * Enable console log streaming from browser to server
-           * @default false
-           */
-          console?: boolean;
-
-          /**
-           * Enable automatic workspace folders for Chrome DevTools
-           *
-           * This lets you persistently edit files in the browser. It works by adding the following route to the server:
-           * `/.well-known/appspecific/com.chrome.devtools.json`
-           *
-           * The response is a JSON object with the following shape:
-           * ```json
-           * {
-           *   "workspace": {
-           *     "root": "<cwd>",
-           *     "uuid": "<uuid>"
-           *   }
-           * }
-           * ```
-           *
-           * The `root` field is the current working directory of the server.
-           * The `"uuid"` field is a hash of the file that started the server and a hash of the current working directory.
-           *
-           * For security reasons, if the remote socket address is not from localhost, 127.0.0.1, or ::1, the request is ignored.
-           * @default true
-           */
-          chromeDevToolsAutomaticWorkspaceFolders?: boolean;
-        };
-
-    type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
-
-    type Handler<Req extends Request, S, Res> = (request: Req, server: S) => MaybePromise<Res>;
-
-    type BaseRouteValue = Response | false | HTMLBundle | BunFile;
-
-    type Routes<WebSocketData, R extends string> = {
-      [Path in R]:
-        | BaseRouteValue
-        | Handler<BunRequest<Path>, Server<WebSocketData>, Response>
-        | Partial<Record<HTTPMethod, Handler<BunRequest<Path>, Server<WebSocketData>, Response> | Response>>;
-    };
-
-    type RoutesWithUpgrade<WebSocketData, R extends string> = {
-      [Path in R]:
-        | BaseRouteValue
-        | Handler<BunRequest<Path>, Server<WebSocketData>, Response | undefined | void>
-        | Partial<
-            Record<HTTPMethod, Handler<BunRequest<Path>, Server<WebSocketData>, Response | undefined | void> | Response>
-          >;
-    };
-
-    type FetchOrRoutes<WebSocketData, R extends string> =
-      | {
-          /**
-           * Handle HTTP requests
-           *
-           * Respond to {@link Request} objects with a {@link Response} object.
-           */
-          fetch?(this: Server<WebSocketData>, req: Request, server: Server<WebSocketData>): MaybePromise<Response>;
-
-          routes: Routes<WebSocketData, R>;
-        }
-      | {
-          /**
-           * Handle HTTP requests
-           *
-           * Respond to {@link Request} objects with a {@link Response} object.
-           */
-          fetch(this: Server<WebSocketData>, req: Request, server: Server<WebSocketData>): MaybePromise<Response>;
-
-          routes?: Routes<WebSocketData, R>;
-        };
-
-    type FetchOrRoutesWithWebSocket<WebSocketData, R extends string> = {
-      /**
-       * Enable websockets with {@link Bun.serve}
-       *
-       * Upgrade a {@link Request} to a {@link ServerWebSocket} via {@link Server.upgrade}
-       *
-       * Pass `data` in {@link Server.upgrade} to attach data to the {@link ServerWebSocket.data} property
-       *
-       * @example
-       * ```js
-       * const server: Bun.Server = Bun.serve({
-       *  websocket: {
-       *    open: (ws) => {
-       *      console.log("Client connected");
-       *    },
-       *    message: (ws, message) => {
-       *      console.log("Client sent message", message);
-       *    },
-       *    close: (ws) => {
-       *      console.log("Client disconnected");
-       *    },
-       *  },
-       *  fetch(req, server) {
-       *    const url = new URL(req.url);
-       *    if (url.pathname === "/chat") {
-       *      const upgraded = server.upgrade(req);
-       *      if (!upgraded) {
-       *        return new Response("Upgrade failed", { status: 400 });
-       *      }
-       *    }
-       *    return new Response("Hello World");
-       *  },
-       * });
-       * ```
-       */
-      websocket: WebSocketHandler<WebSocketData>;
-    } & (
-      | {
-          /**
-           * Handle HTTP requests, or call {@link Server.upgrade} and return early
-           *
-           * Respond to {@link Request} objects with a {@link Response} object.
-           */
-          fetch?(
-            this: Server<WebSocketData>,
-            req: Request,
-            server: Server<WebSocketData>,
-          ): MaybePromise<Response | void | undefined>;
-
-          routes: RoutesWithUpgrade<WebSocketData, R>;
-        }
-      | {
-          /**
-           * Handle HTTP requests, or call {@link Server.upgrade} and return early
-           *
-           * Respond to {@link Request} objects with a {@link Response} object.
-           */
-          fetch(
-            this: Server<WebSocketData>,
-            req: Request,
-            server: Server<WebSocketData>,
-          ): MaybePromise<Response | void | undefined>;
-
-          routes?: RoutesWithUpgrade<WebSocketData, R>;
-        }
-    );
-
-    interface BaseServeOptions<WebSocketData> {
-      /**
-       * Set options for using TLS with this server
-       *
-       * @example
-       * ```ts
-       * const server = Bun.serve({
-       *   fetch: request => new Response("Welcome to Bun!"),
-       *   tls: {
-       *     cert: Bun.file("cert.pem"),
-       *     key: Bun.file("key.pem"),
-       *     ca: [Bun.file("ca1.pem"), Bun.file("ca2.pem")],
-       *   },
-       * });
-       * ```
-       */
-      tls?: TLSOptions | TLSOptions[];
-
-      /**
-       * What is the maximum size of a request body? (in bytes)
-       * @default 1024 * 1024 * 128 // 128MB
-       */
-      maxRequestBodySize?: number;
-
-      /**
-       * Render contextual errors? This enables bun's error page
-       * @default process.env.NODE_ENV !== 'production'
-       */
-      development?: Development;
-
-      /**
-       * Callback called when an error is thrown during request handling
-       * @param error The error that was thrown
-       * @returns A response to send to the client
-       *
-       * @example
-       * ```ts
-       * error: (error) => {
-       *   return new Response("Internal Server Error", { status: 500 });
-       * }
-       * ```
-       */
-      error?: (this: Server<WebSocketData>, error: ErrorLike) => Response | Promise<Response> | void | Promise<void>;
-
-      /**
-       * Uniquely identify a server instance with an ID
-       *
-       * ---
-       *
-       * **When bun is started with the `--hot` flag**:
-       *
-       * This string will be used to hot reload the server without interrupting
-       * pending requests or websockets. If not provided, a value will be
-       * generated. To disable hot reloading, set this value to `null`.
-       *
-       * **When bun is not started with the `--hot` flag**:
-       *
-       * This string will currently do nothing. But in the future it could be useful for logs or metrics.
-       */
-      id?: string | null;
-    }
-
-    interface HostnamePortServeOptions<WebSocketData> extends BaseServeOptions<WebSocketData> {
-      /**
-       * What hostname should the server listen on?
-       *
-       * @default
-       * ```js
-       * "0.0.0.0" // listen on all interfaces
-       * ```
-       * @example
-       *  ```js
-       * "127.0.0.1" // Only listen locally
-       * ```
-       * @example
-       * ```js
-       * "remix.run" // Only listen on remix.run
-       * ````
-       *
-       * note: hostname should not include a {@link port}
-       */
-      hostname?: "0.0.0.0" | "127.0.0.1" | "localhost" | (string & {});
-
-      /**
-       * What port should the server listen on?
-       * @default process.env.PORT || "3000"
-       */
-      port?: string | number;
-
-      /**
-       * Whether the `SO_REUSEPORT` flag should be set.
-       *
-       * This allows multiple processes to bind to the same port, which is useful for load balancing.
-       *
-       * @default false
-       */
-      reusePort?: boolean;
-
-      /**
-       * Whether the `IPV6_V6ONLY` flag should be set.
-       * @default false
-       */
-      ipv6Only?: boolean;
-
-      /**
-       * Sets the number of seconds to wait before timing out a connection
-       * due to inactivity.
-       *
-       * @default 10
-       */
-      idleTimeout?: number;
-    }
-
-    interface UnixServeOptions<WebSocketData> extends BaseServeOptions<WebSocketData> {
-      /**
-       * If set, the HTTP server will listen on a unix socket instead of a port.
-       * (Cannot be used with hostname+port)
-       */
-      unix?: string;
-    }
-
-    /**
-     * The type of options that can be passed to {@link serve}, with support for
-     * `routes` and a safer requirement for `fetch`
-     *
-     * @example
-     * ```ts
-     * export default {
-     *   fetch: req => Response.json(req.url),
-     *
-     *   websocket: {
-     *     message(ws) {
-     *       ws.data.name; // string
-     *     },
-     *   },
-     * } satisfies Bun.Serve.Options<{ name: string }>;
-     * ```
-     */
-    type Options<WebSocketData, R extends string = string> = Bun.__internal.XOR<
-      HostnamePortServeOptions<WebSocketData>,
-      UnixServeOptions<WebSocketData>
-    > &
-      Bun.__internal.XOR<FetchOrRoutes<WebSocketData, R>, FetchOrRoutesWithWebSocket<WebSocketData, R>>;
-  }
-
-  interface BunRequest<T extends string = string> extends Request {
-    readonly params: {
-      [Key in keyof Serve.ExtractRouteParams<T>]: Serve.ExtractRouteParams<T>[Key];
-    } & {};
-    readonly cookies: CookieMap;
-    clone(): BunRequest<T>;
-  }
-
-  /**
-   * HTTP & HTTPS Server
-   *
-   * To start the server, see {@link serve}
-   *
-   * For performance, Bun pre-allocates most of the data for 2048 concurrent requests.
-   * That means starting a new server allocates about 500 KB of memory. Try to
-   * avoid starting and stopping the server often (unless it's a new instance of bun).
-   *
-   * Powered by a fork of [uWebSockets](https://github.com/uNetworking/uWebSockets). Thank you \@alexhultman.
-   */
-  interface Server<WebSocketData> extends Disposable {
-    /**
-     * Stop listening to prevent new connections from being accepted.
-     *
-     * By default, it does not cancel in-flight requests or websockets. That means it may take some time before all network activity stops.
-     *
-     * @param closeActiveConnections Immediately terminate in-flight requests, websockets, and stop accepting new connections.
-     * @default false
-     */
-    stop(closeActiveConnections?: boolean): Promise<void>;
-
-    /**
-     * Update the `fetch` and `error` handlers without restarting the server.
-     *
-     * This is useful if you want to change the behavior of your server without
-     * restarting it or for hot reloading.
-     *
-     * @example
-     *
-     * ```js
-     * // create the server
-     * const server = Bun.serve({
-     *  fetch(request) {
-     *    return new Response("Hello World v1")
-     *  }
-     * });
-     *
-     * // Update the server to return a different response
-     * server.reload({
-     *   fetch(request) {
-     *     return new Response("Hello World v2")
-     *   }
-     * });
-     * ```
-     *
-     * Passing other options such as `port` or `hostname` won't do anything.
-     */
-    reload<R extends string>(options: Serve.Options<WebSocketData, R>): Server<WebSocketData>;
-
-    /**
-     * Mock the fetch handler for a running server.
-     *
-     * This feature is not fully implemented yet. It doesn't normalize URLs
-     * consistently in all cases and it doesn't yet call the `error` handler
-     * consistently. This needs to be fixed
-     */
-    fetch(request: Request | string): Response | Promise<Response>;
-
-    /**
-     * Upgrade a {@link Request} to a {@link ServerWebSocket}
-     *
-     * @param request The {@link Request} to upgrade
-     * @param options Pass headers or attach data to the {@link ServerWebSocket}
-     *
-     * @returns `true` if the upgrade was successful and `false` if it failed
-     *
-     * @example
-     * ```js
-     * import { serve } from "bun";
-     * const server: Bun.Server<{ user: string }> = serve({
-     *   websocket: {
-     *     open: (ws) => {
-     *       console.log("Client connected");
-     *     },
-     *     message: (ws, message) => {
-     *       console.log("Client sent message", message);
-     *     },
-     *     close: (ws) => {
-     *       console.log("Client disconnected");
-     *     },
-     *   },
-     *   fetch(req, server) {
-     *     const url = new URL(req.url);
-     *     if (url.pathname === "/chat") {
-     *       const upgraded = server.upgrade(req, {
-     *         data: {user: "John Doe"}
-     *       });
-     *       if (!upgraded) {
-     *         return new Response("Upgrade failed", { status: 400 });
-     *       }
-     *     }
-     *     return new Response("Hello World");
-     *   },
-     * });
-     * ```
-     *
-     * What you pass to `data` is available on the {@link ServerWebSocket.data} property
-     */
-    upgrade(
-      request: Request,
-      ...options: [WebSocketData] extends [undefined]
-        ? [
-            options?: {
-              /**
-               */
-              headers?: HeadersInit;
-
-              /**
-               * Data to store on the WebSocket instance
-               *
-               * ---
-               *
-               * **Surprised this line is erroring?**
-               *
-               * Tell TypeScript about the WebSocket data by using `Bun.Server<MyWebSocketData>`
-               *
-               * ```ts
-               * const server: Bun.Server<MyWebSocketData> = Bun.serve({
-               *      fetch: (req, server) => {
-               *          const didUpgrade = server.upgrade(req, {
-               *              data: { ... }, // Works now!
-               *          });
-               *      },
-               * });
-               * ```
-               */
-              data?: undefined;
-            },
-          ]
-        : [
-            options: {
-              /**
-               * Send any additional headers while upgrading, like cookies
-               */
-              headers?: HeadersInit;
-
-              /**
-               * Data to store on the WebSocket instance
-               */
-              data: WebSocketData;
-            },
-          ]
-    ): boolean;
-
-    /**
-     * Send a message to all connected {@link ServerWebSocket} subscribed to a topic
-     *
-     * @param topic The topic to publish to
-     * @param data The data to send
-     * @param compress Should the data be compressed? Ignored if the client does not support compression.
-     *
-     * @returns 0 if the message was dropped, -1 if backpressure was applied, or the number of bytes sent.
-     *
-     * @example
-     *
-     * ```js
-     * server.publish("chat", "Hello World");
-     * ```
-     *
-     * @example
-     * ```js
-     * server.publish("chat", new Uint8Array([1, 2, 3, 4]));
-     * ```
-     *
-     * @example
-     * ```js
-     * server.publish("chat", new ArrayBuffer(4), true);
-     * ```
-     *
-     * @example
-     * ```js
-     * server.publish("chat", new DataView(new ArrayBuffer(4)));
-     * ```
-     */
-    publish(
-      topic: string,
-      data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
-      compress?: boolean,
-    ): ServerWebSocketSendStatus;
-
-    /**
-     * A count of connections subscribed to a given topic
-     *
-     * This operation will loop through each topic internally to get the count.
-     *
-     * @param topic the websocket topic to check how many subscribers are connected to
-     * @returns the number of subscribers
-     */
-    subscriberCount(topic: string): number;
-
-    /**
-     * Returns the client IP address and port of the given Request. If the request was closed or is a unix socket, returns null.
-     *
-     * @example
-     * ```js
-     * export default {
-     *  async fetch(request, server) {
-     *    return new Response(server.requestIP(request));
-     *  }
-     * }
-     * ```
-     */
-    requestIP(request: Request): SocketAddress | null;
-
-    /**
-     * Reset the idleTimeout of the given Request to the number in seconds. 0 means no timeout.
-     *
-     * @example
-     * ```js
-     * export default {
-     *  async fetch(request, server) {
-     *    server.timeout(request, 60);
-     *    await Bun.sleep(30000);
-     *    return new Response("30 seconds have passed");
-     *  }
-     * }
-     * ```
-     */
-    timeout(request: Request, seconds: number): void;
-
-    /**
-     * Undo a call to {@link Server.unref}
-     *
-     * If the Server has already been stopped, this does nothing.
-     *
-     * If {@link Server.ref} is called multiple times, this does nothing. Think of it as a boolean toggle.
-     */
-    ref(): void;
-
-    /**
-     * Don't keep the process alive if this server is the only thing left.
-     * Active connections may continue to keep the process alive.
-     *
-     * By default, the server is ref'd.
-     *
-     * To prevent new connections from being accepted, use {@link Server.stop}
-     */
-    unref(): void;
-
-    /**
-     * How many requests are in-flight right now?
-     */
-    readonly pendingRequests: number;
-
-    /**
-     * How many {@link ServerWebSocket}s are in-flight right now?
-     */
-    readonly pendingWebSockets: number;
-
-    readonly url: URL;
-
-    /**
-     * The port the server is listening on.
-     *
-     * This will be undefined when the server is listening on a unix socket.
-     *
-     * @example
-     * ```js
-     * 3000
-     * ```
-     */
-    readonly port: number | undefined;
-
-    /**
-     * The hostname the server is listening on. Does not include the port.
-     *
-     * This will be `undefined` when the server is listening on a unix socket.
-     *
-     * @example
-     * ```js
-     * "localhost"
-     * ```
-     */
-    readonly hostname: string | undefined;
-
-    /**
-     * The protocol the server is listening on.
-     *
-     * - "http" for normal servers
-     * - "https" when TLS is enabled
-     * - null for unix sockets or when unavailable
-     */
-    readonly protocol: "http" | "https" | null;
-
-    /**
-     * Is the server running in development mode?
-     *
-     * In development mode, `Bun.serve()` returns rendered error messages with
-     * stack traces instead of a generic 500 error. This makes debugging easier,
-     * but development mode shouldn't be used in production or you will risk
-     * leaking sensitive information.
-     */
-    readonly development: boolean;
-
-    /**
-     * An identifier of the server instance
-     *
-     * When bun is started with the `--hot` flag, this ID is used to hot reload the server without interrupting pending requests or websockets.
-     *
-     * When bun is not started with the `--hot` flag, this ID is currently unused.
-     */
-    readonly id: string;
-  }
-
-  /**
-   * Bun.serve provides a high-performance HTTP server with built-in routing support.
-   * It enables both function-based and object-based route handlers with type-safe
-   * parameters and method-specific handling.
-   *
-   * @param options Server configuration options
-   *
-   * @example
-   * **Basic Usage**
-   *
-   * ```ts
-   * Bun.serve({
-   *   port: 3000,
-   *   fetch(req) {
-   *     return new Response("Hello World");
-   *   }
-   * });
-   * ```
-   *
-   * @example
-   * **Route-based Handlers**
-   *
-   * ```ts
-   * Bun.serve({
-   *   routes: {
-   *     // Static responses
-   *     "/": new Response("Home page"),
-   *
-   *     // Function handlers with type-safe parameters
-   *     "/users/:id": (req) => {
-   *       // req.params.id is typed as string
-   *       return new Response(`User ${req.params.id}`);
-   *     },
-   *
-   *     // Method-specific handlers
-   *     "/api/posts": {
-   *       GET: () => new Response("Get posts"),
-   *       POST: async (req) => {
-   *         const body = await req.json();
-   *         return new Response("Created post");
-   *       },
-   *       DELETE: (req) => new Response("Deleted post")
-   *     },
-   *
-   *     // Wildcard routes
-   *     "/static/*": (req) => {
-   *       // Handle any path under /static/
-   *       return new Response("Static file");
-   *     },
-   *
-   *     // Disable route (fall through to fetch handler)
-   *     "/api/legacy": false
-   *   },
-   *
-   *   // Fallback handler for unmatched routes
-   *   fetch(req) {
-   *     return new Response("Not Found", { status: 404 });
-   *   }
-   * });
-   * ```
-   *
-   * @example
-   * **Path Parameters**
-   *
-   * ```ts
-   * Bun.serve({
-   *   routes: {
-   *     // Single parameter
-   *     "/users/:id": (req: BunRequest<"/users/:id">) => {
-   *       return new Response(`User ID: ${req.params.id}`);
-   *     },
-   *
-   *     // Multiple parameters
-   *     "/posts/:postId/comments/:commentId": (
-   *       req: BunRequest<"/posts/:postId/comments/:commentId">
-   *     ) => {
-   *       return new Response(JSON.stringify(req.params));
-   *       // Output: {"postId": "123", "commentId": "456"}
-   *     }
-   *   }
-   * });
-   * ```
-   *
-   * @example
-   * **Route Precedence**
-   *
-   * ```ts
-   * // Routes are matched in the following order:
-   * // 1. Exact static routes ("/about")
-   * // 2. Parameter routes ("/users/:id")
-   * // 3. Wildcard routes ("/api/*")
-   *
-   * Bun.serve({
-   *   routes: {
-   *     "/api/users": () => new Response("Users list"),
-   *     "/api/users/:id": (req) => new Response(`User ${req.params.id}`),
-   *     "/api/*": () => new Response("API catchall"),
-   *     "/*": () => new Response("Root catchall")
-   *   }
-   * });
-   * ```
-   *
-   * @example
-   * **Error Handling**
-   *
-   * ```ts
-   * Bun.serve({
-   *   routes: {
-   *     "/error": () => {
-   *       throw new Error("Something went wrong");
-   *     }
-   *   },
-   *   error(error) {
-   *     // Custom error handler
-   *     console.error(error);
-   *     return new Response(`Error: ${error.message}`, {
-   *       status: 500
-   *     });
-   *   }
-   * });
-   * ```
-   *
-   * @example
-   * **Server Lifecycle**
-   *
-   * ```ts
-   * const server = Bun.serve({
-   *   // Server config...
-   * });
-   *
-   * // Update routes at runtime
-   * server.reload({
-   *   routes: {
-   *     "/": () => new Response("Updated route")
-   *   }
-   * });
-   *
-   * // Stop the server
-   * server.stop();
-   * ```
-   *
-   * @example
-   * **Development Mode**
-   *
-   * ```ts
-   * Bun.serve({
-   *   development: true, // Enable hot reloading
-   *   routes: {
-   *     // Routes will auto-reload on changes
-   *   }
-   * });
-   * ```
-   *
-   * @example
-   * **Type-Safe Request Handling**
-   *
-   * ```ts
-   * type Post = {
-   *   id: string;
-   *   title: string;
-   * };
-   *
-   * Bun.serve({
-   *  routes: {
-   *     "/api/posts/:id": async (
-   *       req: BunRequest<"/api/posts/:id">
-   *     ) => {
-   *       if (req.method === "POST") {
-   *         const body: Post = await req.json();
-   *         return Response.json(body);
-   *       }
-   *       return new Response("Method not allowed", {
-   *         status: 405
-   *       });
-   *     }
-   *   }
-   * });
-   * ```
-   */
-  function serve<WebSocketData = undefined, R extends string = never>(
-    options: Serve.Options<WebSocketData, R>,
-  ): Server<WebSocketData>;
-}