resig.js/build/module/streaming/index.d.ts

Universal reactive signal library with complete platform features: signals, animations, CRDTs, scheduling, DOM integration. Works identically across React, SolidJS, Svelte, Vue, and Qwik.

/**
 * Signal-Σ Streaming Infrastructure
 * Advanced streaming, real-time collaboration, and AI integration
 */
export { StreamCoalgebra, StreamingSignal, BackpressureStrategy, StreamState, createStreamingSignal, streamFrom, streamFromIterable, } from './coalgebra';
export { RTCConnectionState, PeerSignaling, WebRTCStreamConfig, WebRTCPeer, BroadcastChannelSignaling, createWebRTCStream, createWebRTCBroadcast, } from './webrtc';
export { Event, CRDTSnapshot, EventStore, CompactionStrategy, EventSourcedConfig, EventSourcedCRDT, MemoryEventStore, IndexedDBEventStore, createEventSourcedCRDT, eventSourcedORSet, eventSourcedGCounter, indexedDBEventStore, } from './event-sourcing';
export { AIModelType, TokenUsage, AITransformer, AIConfig, AIResponse, BaseAITransformer, OpenAITransformer, MockAITransformer, MultiModalTransformer, createLLMTransformer, createVisionModel, composeAITransformers, createBatchAITransformer, } from './ai-transformer';
import { StreamingSignal } from './coalgebra';
/**
 * Create a real-time collaborative signal using WebRTC
 */
export declare const createCollaborativeSignal: <T>(initialValue: T, peerId: string, config?: Record<string, unknown>) => StreamingSignal<T>;
/**
 * Create an AI-enhanced signal that processes input through an AI model
 */
export declare const createAIEnhancedSignal: <I>(initialValue: I, aiModel?: string, config?: Record<string, unknown>) => {
    input: StreamingSignal<I>;
    output: StreamingSignal<string>;
    confidence: import("..").Signal<number>;
    tokens: import("..").Signal<import("./ai-transformer").TokenUsage>;
    isProcessing: import("..").Signal<boolean>;
    setInput: (value: I) => void;
};
/**
 * Create a streaming signal with built-in persistence
 */
export declare const createPersistentStream: <T>(initialValue: T, storageKey: string) => StreamingSignal<T>;
/**
 * Create a throttled streaming signal for performance optimization
 */
export declare const createThrottledStream: <T>(initialValue: T, throttleMs?: number) => StreamingSignal<T>;
/**
 * Create a debounced streaming signal for user input
 */
export declare const createDebouncedStream: <T>(initialValue: T, debounceMs?: number) => StreamingSignal<T>;
/**
 * Create a filtered streaming signal
 */
export declare const createFilteredStream: <T>(initialValue: T, predicate: (value: T) => boolean) => StreamingSignal<T>;
/**
 * Create a transformed streaming signal
 */
export declare const createTransformedStream: <T, U>(initialValue: T, transformer: (value: T) => U) => StreamingSignal<U>;
/**
 * Merge multiple streaming signals into one
 */
export declare const mergeStreams: <T>(...streams: StreamingSignal<T>[]) => StreamingSignal<T>;
/**
 * Create a signal that combines multiple streams
 */
export declare const combineStreams: <T extends Record<string, any>>(streams: { [K in keyof T]: StreamingSignal<T[K]>; }) => StreamingSignal<T>;
/**
 * Create a signal that switches between different streams based on a condition
 */
export declare const switchStream: <T>(condition: StreamingSignal<boolean>, trueStream: StreamingSignal<T>, falseStream: StreamingSignal<T>) => StreamingSignal<T>;
/**
 * Create a signal that accumulates values over time
 */
export declare const createAccumulatorStream: <T, A>(initialValue: T, initialAccumulator: A, accumulator: (acc: A, value: T) => A) => StreamingSignal<A>;
/**
 * Create a signal that samples another signal at regular intervals
 */
export declare const createSampledStream: <T>(source: StreamingSignal<T>, intervalMs: number) => StreamingSignal<T>;
/**
 * Create a signal that only emits distinct values
 */
export declare const createDistinctStream: <T>(source: StreamingSignal<T>, compareFn?: (a: T, b: T) => boolean) => StreamingSignal<T>;