import type { Signal } from '../core/signal';
export type StreamStatus = 'connecting' | 'open' | 'closed' | 'reconnecting';
export interface StreamOptions {
    /** Transport: 'eventsource' (default) or 'fetch' for NDJSON/POST. */
    mode?: 'eventsource' | 'fetch';
    /** HTTP method for fetch mode (default: 'GET'). */
    method?: string;
    /** Custom headers for fetch mode. */
    headers?: Record<string, string>;
    /** Request body for fetch mode (objects are JSON.stringify'd). */
    body?: unknown;
    /** Enable auto-reconnect (default: true). */
    reconnect?: boolean;
    /** Initial reconnect delay in ms (default: 1000). */
    reconnectDelay?: number;
    /** Max reconnect delay in ms (default: 30000). */
    reconnectMaxDelay?: number;
    /** Max reconnect attempts (default: Infinity). */
    reconnectAttempts?: number;
    /** Named SSE events to listen for (eventsource mode only). */
    events?: string[];
    /** Parse each message as JSON (default: true). */
    json?: boolean;
}
export type MessageHandler = (data: unknown, event?: string) => void;
export type OpenHandler = () => void;
export type CloseHandler = () => void;
export type ErrorHandler = (error: Event | Error) => void;
type EventMap = {
    message: MessageHandler;
    open: OpenHandler;
    close: CloseHandler;
    error: ErrorHandler;
};
export interface ManagedStream {
    /** Reactive connection status. */
    readonly status: Signal<StreamStatus>;
    /** Reactive boolean — true when status is 'open'. */
    readonly connected: Signal<boolean>;
    /** Reactive — last received message (parsed JSON or raw string). */
    readonly lastMessage: Signal<unknown>;
    /** Reactive — last SSE event name, or null for unnamed/NDJSON. */
    readonly lastEvent: Signal<string | null>;
    /** Reactive — last error, or null. */
    readonly error: Signal<Event | Error | null>;
    /** Number of reconnect attempts so far. */
    readonly reconnectCount: Signal<number>;
    /** Listen for events. Returns unsubscribe function. */
    on<K extends keyof EventMap>(event: K, handler: EventMap[K]): () => void;
    /** Pipe messages into a signal via a reducer. */
    pipe<T>(target: Signal<T>, reducer: (message: unknown, current: T) => T): () => void;
    /** Close the connection and stop reconnecting. */
    close(): void;
}
declare function createStream(url: string, options?: StreamOptions): ManagedStream;
export declare const sse: {
    connect: typeof createStream;
};
export {};
//# sourceMappingURL=sse.d.ts.map