/**
 * Async / streaming render entry points.
 *
 * Builds on top of the synchronous `renderToString()` and adds:
 * - `renderToStringAsync()` — awaits Promise/`defer()` values in the context.
 * - `renderToStream()` — emits the HTML as a Web `ReadableStream<Uint8Array>`.
 * - `renderToResponse()` — wraps the stream in a `Response` with sensible
 *   defaults (`Content-Type`, `Cache-Control`, ETag, head injection, store
 *   state injection).
 *
 * All three run on Bun, Deno and Node ≥ 24 without external dependencies.
 *
 * @module bquery/ssr
 */
import type { BindingContext } from '../view/types';
import { type SSRContext } from './context';
import type { RenderOptions, SSRResult } from './types';
/**
 * Options accepted by the async render APIs. Extends the base `RenderOptions`
 * with response-shaping switches.
 */
export interface AsyncRenderOptions extends RenderOptions {
    /** Pre-built SSR context. Created automatically if omitted. */
    context?: SSRContext;
    /**
     * Whether to inject the head manager output, asset manifest and store-state
     * `<script>` tag into the output HTML when the template contains
     * `</head>`/`</body>` markers. Default: `true`.
     */
    injectHead?: boolean;
    /**
     * Custom store-state script ID/global key forwarded to `serializeStoreState()`.
     */
    storeScriptId?: string;
    storeGlobalKey?: string;
}
/** Result of an async render call. */
export interface AsyncSSRResult extends SSRResult {
    /** SSR context that produced this result. */
    context: SSRContext;
    /** Aggregated head HTML (already injected when `injectHead` is true). */
    headHtml: string;
    /** Aggregated asset preload HTML (already injected when `injectHead` is true). */
    assetsHtml: string;
    /** `<script>` tag with serialized store state, if any. */
    storeScriptTag: string;
}
/**
 * Async-aware render. Resolves all `Promise`/`defer()` values in the context,
 * then delegates to `renderToString()` and applies head/asset/store-state
 * injection based on the SSR context.
 */
export declare const renderToStringAsync: (template: string, data: BindingContext, options?: AsyncRenderOptions) => Promise<AsyncSSRResult>;
/**
 * Renders a template into a Web `ReadableStream<Uint8Array>`. The stream is
 * single-chunk for now (the HTML is fully resolved before flushing) but is
 * exposed as a stream so adapters can pipe it directly into Bun/Deno/Node
 * responses without buffering into memory twice.
 *
 * Future Suspense-style streaming patches will reuse the same return type.
 */
export declare const renderToStream: (template: string, data: BindingContext, options?: AsyncRenderOptions) => ReadableStream<Uint8Array>;
/** Options for `renderToResponse()`. */
export interface RenderToResponseOptions extends AsyncRenderOptions {
    /** Override the response status code. */
    status?: number;
    /** Override the `Content-Type` header. Default: `text/html; charset=utf-8`. */
    contentType?: string;
    /** Set a `Cache-Control` header value. */
    cacheControl?: string;
    /** Whether to compute a weak ETag from the rendered HTML. Default: `false`. */
    etag?: boolean;
    /** Extra headers merged into the response. */
    headers?: HeadersInit;
}
/**
 * Renders a template and returns a `Response` ready to be returned from a
 * `fetch`-style handler (`Bun.serve`, `Deno.serve`, Hono, Elysia, etc.).
 *
 * Honours `SSRContext.signal` for cancellation and `SSRContext.responseHeaders`
 * for headers added during the render path.
 */
export declare const renderToResponse: (template: string, data: BindingContext, options?: RenderToResponseOptions) => Promise<Response>;
//# sourceMappingURL=render-async.d.ts.map