/**
 * `Wire<T, E>` — fluent stream wrapper.
 *
 * @module
 */
import { Effect, Stream } from 'effect';
import type { Millis } from './brands.js';
interface WireShape<T, E = never> {
    readonly _tag: 'Wire';
    readonly stream: Stream.Stream<T, E>;
    map<B>(f: (a: T) => B): WireShape<B, E>;
    filter(f: (a: T) => boolean): WireShape<T, E>;
    take(n: number): WireShape<T, E>;
    takeUntil(predicate: (a: T) => boolean): WireShape<T, E>;
    debounce(ms: Millis): WireShape<T, E>;
    throttle(ms: Millis): WireShape<T, E>;
    scan<B>(initial: B, f: (acc: B, value: T) => B): WireShape<B, E>;
    flatMap<B, E2>(f: (a: T) => WireShape<B, E2>): WireShape<B, E | E2>;
    merge<B, E2>(other: WireShape<B, E2>): WireShape<T | B, E | E2>;
    run(): Effect.Effect<void, E>;
    runCollect(): Effect.Effect<T[], E>;
}
/**
 * Creates a Wire from a WebSocket connection.
 * The socket is closed when the stream finalizes.
 *
 * @example
 * ```ts
 * const wire = Wire.fromWebSocket('wss://example.com/ws');
 * const messages = wire.map(evt => evt.data as string);
 * await Effect.runPromise(Wire.runForEach(messages, m => Effect.log(m)));
 * ```
 */
/**
 * The WebSocket surface {@link Wire.fromWebSocket} actually drives. Named so
 * the dependency is structural rather than ambient: test doubles
 * (tests/helpers/mock-websocket.ts) conform to THIS type, and any drift
 * between what the Wire consumes and what the double provides breaks the
 * build instead of silently diverging.
 */
export interface WireSocket {
    onmessage: ((event: MessageEvent) => void) | null;
    onerror: ((event: Event) => void) | null;
    onclose: ((event: CloseEvent) => void) | null;
    readonly readyState: number;
    close(): void;
}
/**
 * Wire -- fluent stream wrapper with chainable operators for map, filter,
 * scan, debounce, throttle, merge, and more. Wraps Effect Streams.
 *
 * @example
 * ```ts
 * const wire = Wire.from(Stream.make(1, 2, 3, 4, 5));
 * const result = wire.filter(n => n > 2).map(n => n * 10);
 * const values = Effect.runSync(result.runCollect()); // [30, 40, 50]
 * ```
 */
export declare const Wire: {
    from: <T, E = never>(stream: Stream.Stream<T, E>) => WireShape<T, E>;
    fromSSE: (url: string, options?: EventSourceInit) => WireShape<MessageEvent, Error>;
    fromWebSocket: (url: string, protocols?: string | string[]) => WireShape<MessageEvent, Error>;
    fromAsyncIterable: <T>(iterable: AsyncIterable<T>) => WireShape<T, Error>;
    zip: <A, B>(a: WireShape<A>, b: WireShape<B>) => WireShape<readonly [A, B]>;
    merge: <T, E>(streams: ReadonlyArray<WireShape<T, E>>) => WireShape<T, E>;
    runCollect: <T, E>(stream: WireShape<T, E>) => Effect.Effect<ReadonlyArray<T>, E>;
    runForEach: <T, SE, E, R>(stream: WireShape<T, SE>, fn: (t: T) => Effect.Effect<void, E, R>) => Effect.Effect<void, SE | E, R>;
};
export declare namespace Wire {
    /** Structural shape of a {@link Wire}: a fluent wrapper over `Stream.Stream<T, E>`. */
    type Shape<T, E = never> = WireShape<T, E>;
}
export {};
//# sourceMappingURL=wire.d.ts.map