/**
 * Runtime adapters for SSR.
 *
 * Provide thin glue functions that turn a bQuery render handler into a
 * runtime-native server callback. They share a common signature so the same
 * application can be served by Bun, Deno, Node and any Web-`fetch` host.
 *
 * @module bquery/ssr
 */
import type { SSRContext } from './context';
/** A handler that turns a request into a Response (Web-fetch style). */
export type SSRRequestHandler = (request: Request, context?: SSRContext) => Promise<Response> | Response;
/**
 * Identity adapter for Web-`fetch` style hosts (Hono, Elysia, Workerd, edge
 * runtimes). Exists for symmetry and future logging hooks.
 */
export declare const createWebHandler: (handler: SSRRequestHandler) => SSRRequestHandler;
/**
 * Wraps a handler for `Bun.serve()`. Returns a function with Bun's expected
 * signature `(request, server) => Response | Promise<Response>`.
 */
export declare const createBunHandler: (handler: SSRRequestHandler) => ((request: Request) => Promise<Response>);
/**
 * Wraps a handler for `Deno.serve()`. Returns a function with Deno's expected
 * signature `(request, info?) => Response | Promise<Response>`.
 */
export declare const createDenoHandler: (handler: SSRRequestHandler) => ((request: Request) => Promise<Response>);
/** Minimal subset of `node:http` IncomingMessage we rely on. */
export interface NodeIncomingMessage {
    url?: string;
    method?: string;
    headers: Record<string, string | string[] | undefined>;
    on(event: 'data', listener: (chunk: Uint8Array | string) => void): void;
    on(event: 'end', listener: () => void): void;
    on(event: 'error', listener: (err: unknown) => void): void;
    destroy?(error?: Error): void;
}
/** Minimal subset of `node:http` ServerResponse we rely on. */
export interface NodeServerResponse {
    statusCode: number;
    setHeader(name: string, value: string | number | readonly string[]): void;
    write(chunk: Uint8Array | string): boolean;
    end(chunk?: Uint8Array | string): void;
    once?(event: 'drain' | 'error', listener: (error?: unknown) => void): void;
    on?(event: 'drain' | 'error', listener: (error?: unknown) => void): void;
}
/** Optional hardening settings for the `node:http` adapter. */
export interface NodeHandlerOptions {
    /** Reject request bodies that exceed this many bytes. Default: unlimited. */
    maxBodyBytes?: number;
}
/**
 * Wraps a handler so it can be passed directly to a `node:http` server.
 *
 * @example
 * ```ts
 * import { createServer } from 'node:http';
 * import { createNodeHandler, renderToResponse } from '@bquery/bquery/ssr';
 *
 * const handler = createNodeHandler(async (request) => {
 *   return renderToResponse('<div bq-text="msg"></div>', { msg: 'Hello' });
 * });
 *
 * createServer(handler).listen(3000);
 * ```
 */
export declare const createNodeHandler: (handler: SSRRequestHandler, options?: NodeHandlerOptions) => ((req: NodeIncomingMessage, res: NodeServerResponse) => Promise<void>);
/**
 * Convenience helper that picks the right adapter based on the current
 * runtime. Returns the same handler unchanged for Web/Bun/Deno (they share a
 * fetch-style signature). On Node it returns the `node:http` adapter.
 */
export declare const createSSRHandler: (handler: SSRRequestHandler) => SSRRequestHandler | ((req: NodeIncomingMessage, res: NodeServerResponse) => Promise<void>);
//# sourceMappingURL=adapters.d.ts.map