/**
 * Stream Coalgebra System
 * Mathematical foundation for streaming signals using coalgebra patterns
 * Following the pattern: State → (Output × State)
 */
import { Signal } from '../core/signal';
export interface StreamCoalgebra<S, O> {
    observe: (state: S) => O;
    transition: (state: S) => S;
}
export type BackpressureStrategy = 'drop' | 'buffer' | 'error';
export interface StreamState<T> {
    buffer: T[];
    lastEmitted: number;
    isActive: boolean;
    errorCount: number;
}
export interface StreamingSignal<T> extends Signal<T> {
    stream(): AsyncIterable<T>;
    buffer(size: number): Signal<T[]>;
    throttle(ms: number): StreamingSignal<T>;
    backpressure(strategy: BackpressureStrategy): StreamingSignal<T>;
    take(count: number): StreamingSignal<T>;
    skip(count: number): StreamingSignal<T>;
    filter(predicate: (value: T) => boolean): StreamingSignal<T>;
    transform<U>(fn: (value: T) => U): StreamingSignal<U>;
    merge(other: StreamingSignal<T>): StreamingSignal<T>;
    debounce(ms: number): StreamingSignal<T>;
}
export declare const createStreamingSignal: <T>(initialValue: T, coalgebra?: StreamCoalgebra<StreamState<T>, T>) => StreamingSignal<T>;
export declare const streamFrom: <T>(...values: T[]) => StreamingSignal<T>;
export declare const streamFromIterable: <T>(iterable: AsyncIterable<T>) => StreamingSignal<T>;