import type { StoredStreamChunk } from '../../core/context.ts';
import type { OperationFault } from '../operation-fault.ts';
import { type Cursor } from '../workflow-event-feed.ts';
export type ServerSentEventTimerScheduler = (callback: () => void, intervalMs: number) => () => void;
export type ServerSentEventHeartbeatOptions = {
    readonly intervalMs: number;
    readonly schedule?: ServerSentEventTimerScheduler;
    readonly now?: () => number;
};
type ServerSentEventEnvelope = {
    readonly kind: string;
    readonly cursor: string;
    readonly emittedAtMs: number;
};
type EventEnvelopeSSEStreamOptions<TEnvelope extends ServerSentEventEnvelope> = {
    readonly iterable: AsyncIterable<TEnvelope>;
    readonly close: () => Promise<void>;
    readonly ready?: Promise<void>;
    readonly heartbeat?: ServerSentEventHeartbeatOptions;
    readonly signal?: AbortSignal;
};
export declare const SSE_ACCEPT_REQUIRED_MESSAGE = "Accept header must include text/event-stream";
export declare function acceptsServerSentEvents(acceptHeader: string | null): boolean;
export declare function requireServerSentEventsAccept(request: Request): void;
/**
 * Validate an SSE reconnect cursor taken from a `Last-Event-ID` header or
 * `fromCursor` query parameter. Returns `undefined` for an absent value and
 * throws an `InvalidParams` fault for a malformed one. Shared by every SSE
 * binding so cursor validation stays defined in exactly one place.
 */
export declare function readServerSentEventsCursor(value: string | null): Cursor | undefined;
export declare function shapeServerSentEventsFault(fault: OperationFault): Response;
/** Format a single Server-Sent Events message. */
export declare function formatServerSentEvent(event: {
    readonly id?: string;
    readonly event?: string;
    readonly data: string;
}): string;
/**
 * Convert a replay-plus-live event envelope iterable into an SSE byte stream.
 * Event envelopes advance the client cursor via `id`; heartbeat pings do not.
 */
export declare function createEventEnvelopeSSEStream<TEnvelope extends ServerSentEventEnvelope>(options: EventEnvelopeSSEStreamOptions<TEnvelope>): ReadableStream<Uint8Array>;
/**
 * Wrap a list of stored stream chunks as a Server-Sent Events stream. Each
 * chunk gets emitted as a `token` event keyed by `chunk.sequence`; chunks
 * whose mapped text is `null` are skipped. After the chunks, a single
 * `done` event with empty data is emitted and the controller closes.
 *
 * Used by REST `shapeSuccess` for the streaming routes (`streamSSE`,
 * `getStreamChunks` when negotiated to `text/event-stream`).
 */
export declare function createStoredChunkSSEStream(chunks: ReadonlyArray<StoredStreamChunk>, mapChunkToText: (chunk: StoredStreamChunk) => string | null): ReadableStream<Uint8Array>;
/** Standard headers for an SSE response. */
export declare const SSE_RESPONSE_HEADERS: Readonly<Record<string, string>>;
export {};