/**
 * Nexus Streaming SSR — Out-of-order HTML flushing with Suspense boundaries.
 *
 * How it works:
 *
 *   1. The route render function returns immediately with the static shell.
 *      Any Promise in the template becomes a placeholder:
 *        <template id="nx-hole-3a9f"></template>
 *
 *   2. The HTTP connection stays OPEN (Transfer-Encoding: chunked).
 *      The browser receives and paints the static shell instantly.
 *
 *   3. When each Promise resolves, the server writes two chunks:
 *      a) The resolved HTML wrapped in a <template id="nx-fill-3a9f">
 *      b) A tiny inline script that moves the template content
 *         to the hole's position and removes both elements.
 *
 *   4. Error boundary: if a Promise rejects, the server writes the
 *      error.nx fallback HTML instead.
 *
 * Result: Users see content as it becomes available, not all-at-once.
 *         The Time-to-First-Byte is the server's fastest possible response.
 *
 * Wire format (chunks sent over HTTP):
 *   Chunk 1: Full HTML with placeholders
 *     <div>Static content</div>
 *     <template id="nx-hole-3a9f" data-nx-fallback="<p>Loading...</p>"></template>
 *     <template id="nx-hole-7b2c"></template>
 *
 *   Chunk 2: Resolved content (arrives async)
 *     <template id="nx-fill-3a9f"><article>...</article></template>
 *     <script>__nx_fill("3a9f")</script>
 *
 *   Chunk 3: Another resolution or error boundary
 *     <template id="nx-fill-7b2c"><div class="error">...</div></template>
 *     <script>__nx_fill("7b2c")</script>
 *
 *   Final chunk (closes stream):
 *     <script>__nx_stream_complete()</script>
 */
/**
 * Resolved deferred chunk: plain HTML, or body + optional Pretext wire + dev bridge script.
 * Pretext wire must be the same string produced by `serialize(ctx.pretext)` for `#__NEXUS_PRETEXT__`.
 */
export type StreamingPromiseValue = string | {
    html: string;
    pretextWire?: string;
    devBridgeScript?: string;
};
export interface StreamingBoundary {
    id: string;
    /** The promise that will resolve to HTML (or a structured payload for Pretext streaming). */
    promise: Promise<StreamingPromiseValue>;
    /** Fallback HTML shown while the promise is pending. Injected next to the hole immediately on page paint. */
    fallback?: string;
    /** Error boundary HTML or factory. Overrides `onError` at the boundary level. */
    errorFallback?: string | ((err: unknown) => string);
}
export interface StreamController {
    /** Write the initial HTML shell (immediately) */
    writeShell: (html: string) => void;
    /** Register a deferred content promise */
    defer: (boundary: StreamingBoundary) => void;
    /** Signal stream completion */
    close: () => void;
}
/**
 * Creates a streaming SSR response.
 * Returns a Web-standard `ReadableStream` for use in any edge runtime.
 */
export declare function createStreamingResponse(renderFn: (ctrl: StreamController) => void | Promise<void>, opts?: {
    headers?: HeadersInit;
    onError?: (err: unknown) => string;
}): Response;
/**
 * Template tag for deferred content in .nx templates.
 *
 * Usage in template:
 *   {#await fetchPosts()}
 *     <p>Loading posts...</p>
 *   {:then posts}
 *     {#each posts as p}<article>{p.title}</article>{/each}
 *   {:catch error}
 *     <p class="error">{error.message}</p>
 *   {/await}
 *
 * Compiled output:
 *   createSuspenseBoundary(fetchPosts(), {
 *     fallback: '<p>Loading posts...</p>',
 *     render: (posts) => posts.map(...).join(''),
 *   })
 */
export declare function createSuspenseBoundary<T>(promise: Promise<T>, opts: {
    fallback?: string;
    render: (value: T) => string;
    errorFallback?: string | ((err: unknown) => string);
}): {
    id: string;
    placeholder: string;
    boundary: StreamingBoundary;
};
/**
 * Pipes a streaming response to a Node.js `ServerResponse`.
 * Used by the Node.js server adapter.
 */
export declare function pipeToNodeResponse(webResponse: Response, nodeRes: import('node:http').ServerResponse, mergeHeaders?: (h: Record<string, string>) => Record<string, string | string[] | number>): Promise<void>;
/** Stable hole id for streaming Pretext (shell + one deferred body chunk). */
export declare function nextStreamBoundaryId(): string;
//# sourceMappingURL=streaming.d.ts.map