reactor-core-ts 2.1.6 → 3.2.1

package/dist/index.d.ts

@@ -1,2557 +1,18 @@
 /**
- * Represents a subscription to a Publisher.
- * Manages the flow of data and provides the ability to cancel the subscription.
- */
-interface Subscription {
-    /**
-     * Requests a specified number of items from the Publisher.
-     * Allows controlling backpressure by specifying how many items to emit.
-     * @param {number} count - The number of items to request from the Publisher.
-     */
-    request(count: number): void;
-    /**
-     * Cancels the subscription, stopping any further emissions.
-     * Unsubscribing releases resources associated with the subscription.
-     */
-    unsubscribe(): void;
-}
-
-/**
- * Represents a subscriber that listens to events emitted by a Publisher.
- *
- * Reactive Streams spec: the Publisher MUST call onSubscribe before any other signal.
- * The Subscriber SHOULD call Subscription.request(n) from within onSubscribe.
- *
- * @template T - The type of data that the subscriber will receive.
- */
-interface Subscriber<T> {
-    /**
-     * Called once by the Publisher immediately after subscribe().
-     * MUST be called before onNext, onError, or onComplete.
-     * @param {Subscription} subscription - The subscription controlling demand and cancellation.
-     */
-    onSubscribe(subscription: Subscription): void;
-    /**
-     * Called when the next item is emitted.
-     * @param {T} value - The next value emitted by the Publisher.
-     */
-    onNext(value: T): void;
-    /**
-     * Called when an error occurs during data emission.
-     * @param {Error} error - The error encountered.
-     */
-    onError(error: Error): void;
-    /**
-     * Called when the Publisher has successfully completed emitting all items.
-     */
-    onComplete(): void;
-}
-
-/**
- * Represents a generic publisher that can subscribe to a data stream.
- * @template T - The type of data being published.
- */
-interface Publisher<T> {
-    /**
-     * Subscribes a subscriber to the publisher.
-     * @param {Subscriber<T>} subscriber - The subscriber to receive published data.
-     * @returns {Subscription} A subscription object to manage the subscriber's lifecycle.
-     */
-    subscribe(subscriber: Subscriber<T>): Subscription;
-}
-
-/**
- * Represents a sink that consumes emitted values, errors, and completion signals.
- * Typically used as the endpoint in a reactive stream to receive and handle data.
- *
- * @template T - The type of data being consumed.
- */
-interface Sink<T> {
-    /**
-     * Consumes the next emitted value.
-     * Called when a new value is pushed to the sink.
-     * @param {T} value - The value to be processed.
-     */
-    next(value: T): void;
-    /**
-     * Handles an error emitted during the data stream.
-     * Called when an error occurs within the publisher.
-     * @param {Error} error - The error encountered.
-     */
-    error(error: Error): void;
-    /**
-     * Signals the completion of the data stream.
-     * Called when the publisher has finished emitting all values.
-     */
-    complete(): void;
-}
-
-/**
- * Represents a basic scheduling interface for executing tasks.
- */
-interface Scheduler {
-    /**
-     * Schedules a task to be executed.
-     * @param {Function} task - The task function to be executed.
-     */
-    schedule(task: () => void): void;
-}
-/**
- * Represents a cancellable scheduling interface, extending the basic `Scheduler` interface.
- * Provides the ability to cancel a scheduled task.
- */
-interface CancellableScheduler extends Scheduler {
-    /**
-     * Schedules a task to be executed with the ability to cancel it.
-     * @param {Function} task - The task function to be executed.
-     * @returns {Object} An object containing a `cancel` method to stop the execution.
-     */
-    schedule(task: () => void): {
-        cancel: () => void;
-    };
-}
-
-/**
- * An interface representing a publisher that supports data transformation and manipulation through pipes.
- * @template T - The type of data being published.
- */
-interface PipePublisher<T> extends Publisher<T> {
-    /**
-     * Pipes the data through custom transformations.
-     * @template R - The result type after processing.
-     * @param {Function} producer - The function to produce new values.
-     * @param {Function} onSubscribe - Callback on subscription.
-     * @param {Function} onRequest - Callback on request.
-     * @param {Function} onUnsubscribe - Callback on unsubscribe.
-     * @returns {PipePublisher<R>} A new pipe publisher with transformed data.
-     */
-    pipe<R>(producer: (onNext: (value: R) => void, onError: (error: Error) => void, onComplete: () => void) => void, onRequest: (request: number) => void, onUnsubscribe: () => void): PipePublisher<R>;
-    /**
-     * Transforms each emitted value using the given function.
-     * @template R - The transformed data type.
-     * @param {Function} fn - The mapping function.
-     * @returns {PipePublisher<R>} A new pipe publisher with mapped data.
-     */
-    map<R>(fn: (value: T) => R): PipePublisher<R>;
-    /**
-     * Transforms each emitted value and filter transform result.
-     * @template R - The transformed data type.
-     * @param {Function} fn - The mapping function that can return null or undefined.
-     * @returns {PipePublisher<R>} A new pipe publisher with mapped non-null data.
-     */
-    mapNotNull<R>(fn: (value: T) => R | null | undefined): PipePublisher<R>;
-    /**
-     * Transforms the value using a function that returns a new publisher.
-     * @template R - The resulting data type.
-     * @param {Function} fn - The function to transform values into new publishers.
-     * @returns {PipePublisher<R>} A pipe publisher that flattens the result.
-     */
-    flatMap<R>(fn: (value: T) => Publisher<R>): PipePublisher<R>;
-    /**
-     * Filters emitted values using a given predicate.
-     * @param {Function} predicate - The function to determine whether to emit a value.
-     * @returns {PipePublisher<T>} A new pipe publisher with filtered data.
-     */
-    filter(predicate: (value: T) => boolean): PipePublisher<T>;
-    /**
-     * Filters emitted values based on a publisher that returns a boolean.
-     * @param {Function} predicate - A function returning a boolean publisher.
-     * @returns {PipePublisher<T>} A new pipe publisher with conditional data.
-     */
-    filterWhen(predicate: (value: T) => Publisher<boolean>): PipePublisher<T>;
-    /**
-     * Casts the current publisher to another type.
-     * @template R - The target type.
-     * @returns {PipePublisher<R>} The casted pipe publisher.
-     */
-    cast<R>(): PipePublisher<R>;
-    /**
-     * Switches to an alternative publisher if the current one is empty.
-     * @param {Publisher<T>} alternative - The alternative publisher.
-     * @returns {PipePublisher<T>} A new pipe publisher.
-     */
-    switchIfEmpty(alternative: Publisher<T>): PipePublisher<T>;
-    /**
-     * Continues with a replacement publisher if an error occurs.
-     * @param {Publisher<T>} replacement - The publisher to switch to on error.
-     * @returns {PipePublisher<T>} A new pipe publisher.
-     */
-    onErrorReturn(replacement: Publisher<T>): PipePublisher<T>;
-    /**
-     * Continues processing even if an error occurs based on a predicate.
-     * @param {Function} predicate - Function to determine whether to continue on error.
-     * @returns {PipePublisher<T>} A new pipe publisher.
-     */
-    onErrorContinue(predicate: (error: Error) => boolean): PipePublisher<T>;
-    /**
-     * Executes a function when the first value is emitted.
-     * @param {Function} fn - The function to execute.
-     * @returns {PipePublisher<T>} A new pipe publisher.
-     */
-    doFirst(fn: () => void): PipePublisher<T>;
-    /**
-     * Executes a function when each value is emitted.
-     * @param {Function} fn - The function to execute on each value.
-     * @returns {PipePublisher<T>} A new pipe publisher.
-     */
-    doOnNext(fn: (value: T) => void): PipePublisher<T>;
-    /**
-     * Executes a function when each error is emitted.
-     * @param {Function} fn - The function to execute on each error.
-     * @returns {PipePublisher<T>} A new pipe publisher.
-     */
-    doOnError(fn: (value: Error) => void): PipePublisher<T>;
-    /**
-     * Executes a function when the stream completes.
-     * @param {Function} fn - The function to execute on completion.
-     * @returns {PipePublisher<T>} A new pipe publisher.
-     */
-    doFinally(fn: () => void): PipePublisher<T>;
-    /**
-     * Executes a function when a subscription occurs.
-     * @param {Function} fn - The function to execute on subscription.
-     * @returns {PipePublisher<T>} A new pipe publisher.
-     */
-    doOnSubscribe(fn: (subscription: Subscription) => void): PipePublisher<T>;
-    /**
-     * Publishes values on a specified scheduler.
-     * @param {Scheduler} scheduler - The scheduler to use.
-     * @returns {PipePublisher<T>} A new pipe publisher.
-     */
-    publishOn(scheduler: Scheduler): PipePublisher<T>;
-    /**
-     * Subscribes to the stream on a specified scheduler.
-     * @param {Scheduler} scheduler - The scheduler to use.
-     * @returns {PipePublisher<T>} A new pipe publisher.
-     */
-    subscribeOn(scheduler: Scheduler): PipePublisher<T>;
-}
-
-/**
- * Represents a reactive signal — one of the three events that can be emitted
- * by a {@link Publisher}: a value (`next`), a terminal error (`error`), or
- * a normal completion (`complete`).
- *
- * `Signal` is the type used by {@link Flux#materialize} /
- * {@link Flux#dematerialize} to pass reactive events as plain data values.
- *
- * @typeParam T - The type of the value carried by a `next` signal.
- */
-type Signal<T> = {
-    readonly kind: 'next';
-    readonly value: T;
-} | {
-    readonly kind: 'error';
-    readonly error: Error;
-} | {
-    readonly kind: 'complete';
-};
-/**
- * Namespace of factory helpers for creating {@link Signal} instances.
- */
-declare const Signal: {
-    /**
-     * Creates a `next` signal carrying `value`.
-     * @param value - The item to wrap.
-     */
-    next<T>(value: T): Signal<T>;
-    /**
-     * Creates an `error` signal carrying `error`.
-     * @param error - The error to wrap.
-     */
-    error<T>(error: Error): Signal<T>;
-    /**
-     * Creates a `complete` signal.
-     */
-    complete<T>(): Signal<T>;
-};
-
-/**
- * Base class for Flux and Mono providing the common operator implementations
- * that are identical across both types. Operators that preserve T use the
- * abstract `wrapSource` factory so that subclasses always return their own
- * concrete type (Flux → Flux, Mono → Mono) without any unsafe casts at
- * call-sites.
- *
- * Operators NOT included here (different semantics or change the type):
- *  - filter / filterWhen  — demand-replenishment differs between Flux and Mono
- *  - doFinally            — Flux also fires fn on cancel; Mono does not
- *  - map / flatMap / cast / pipe / mapNotNull — change the type T → R
- */
-declare abstract class AbstractPipePublisher<T, Self> implements Publisher<T> {
-    protected readonly source: Publisher<T>;
-    protected constructor(source: Publisher<T>);
-    /**
-     * Default demand issued in the auto-request onSubscribe when using the
-     * convenience subscribe() overloads (no explicit Subscriber provided).
-     * Mono overrides this to 1; Flux overrides it to Number.MAX_SAFE_INTEGER.
-     */
-    protected abstract defaultDemand(): number;
-    /**
-     * Subscribe with a full Subscriber (existing contract — full demand control).
-     */
-    subscribe(subscriber: Subscriber<T>): Subscription;
-    /**
-     * Convenience overload — any combination of callbacks may be omitted.
-     * An auto-request of `defaultDemand()` is issued on subscribe so items
-     * start flowing immediately without a manual request() call.
-     *
-     * If `onError` is not provided, unhandled errors are re-thrown so they
-     * surface as uncaught exceptions rather than being silently swallowed.
-     *
-     * @example
-     * // Mono — requests 1 automatically
-     * Mono.just(42).subscribe(v => console.log(v));
-     *
-     * // Flux — requests unbounded automatically
-     * Flux.range(0, 5).subscribe(v => console.log(v), err => console.error(err));
-     */
-    subscribe(onNext?: (value: T) => void, onError?: (error: Error) => void, onComplete?: () => void): Subscription;
-    /**
-     * Wraps a publisher in the concrete subclass type.
-     * Called internally by every operator that preserves T.
-     */
-    protected abstract wrapSource(source: Publisher<T>): Self;
-    /**
-     * Falls back to `alternative` if this source completes without emitting any items.
-     *
-     * If the source emits at least one item, `alternative` is never subscribed to.
-     * If the source errors, the error is forwarded and `alternative` is not subscribed to.
-     *
-     * @param alternative - Publisher to subscribe to if the source is empty.
-     * @returns A publisher that uses `alternative` when the source is empty.
-     */
-    switchIfEmpty(alternative: Publisher<T>): Self;
-    /**
-     * Substitutes the error signal with items from `replacement`.
-     *
-     * When the source signals `onError`, `replacement` is subscribed to and its items are
-     * forwarded downstream as if they came from the original source.
-     * If `replacement` itself errors, that error is forwarded.
-     *
-     * @param replacement - Publisher whose items replace the error.
-     * @returns A publisher that recovers from errors by switching to `replacement`.
-     */
-    onErrorReturn(replacement: Publisher<T>): Self;
-    /**
-     * Handles errors selectively: if `predicate(error)` returns `true`, the error is
-     * swallowed and the stream completes normally; otherwise the error is forwarded.
-     *
-     * @param predicate - Receives the error and returns `true` to suppress it.
-     * @returns A publisher that converts matching errors into normal completions.
-     */
-    onErrorContinue(predicate: (error: Error) => boolean): Self;
-    /**
-     * Executes a side-effect `fn` on the **first** item emitted by the source.
-     *
-     * Subsequent items pass through unchanged. Any exception thrown by `fn` is silently swallowed.
-     *
-     * @param fn - Side-effect to run on the very first item.
-     * @returns A publisher with the side effect attached to the first item.
-     */
-    doFirst(fn: () => void): Self;
-    /**
-     * Executes a side-effect `fn` for every item emitted by the source, before
-     * forwarding the item downstream.
-     *
-     * Any exception thrown by `fn` is silently swallowed; the item is still forwarded.
-     *
-     * @param fn - Side-effect called for each item.
-     * @returns A publisher with the side effect attached to each item.
-     */
-    doOnNext(fn: (value: T) => void): Self;
-    /**
-     * Executes a side-effect `fn` when the source signals an error, before
-     * forwarding the error downstream.
-     *
-     * Any exception thrown by `fn` is silently swallowed; the original error is still forwarded.
-     *
-     * @param fn - Side-effect called with the error.
-     * @returns A publisher with the side effect attached to the error signal.
-     */
-    doOnError(fn: (error: Error) => void): Self;
-    /**
-     * Executes a side-effect `fn` when the source calls `onSubscribe`, passing the
-     * resulting {@link Subscription} to the callback.
-     *
-     * Any exception thrown by `fn` is silently swallowed.
-     *
-     * @param fn - Side-effect called with the subscription object.
-     * @returns A publisher with the side effect attached to the subscribe event.
-     */
-    doOnSubscribe(fn: (subscription: Subscription) => void): Self;
-    /**
-     * Shifts item delivery to the given `scheduler`.
-     *
-     * Each `onNext`, `onError`, and `onComplete` callback is scheduled on `scheduler`
-     * instead of being called inline. The source is still subscribed to on the
-     * calling thread; only the *delivery* of signals is redirected.
-     *
-     * @param scheduler - The scheduler on which downstream signals are delivered.
-     * @returns A publisher that delivers signals on the given scheduler.
-     */
-    publishOn(scheduler: Scheduler): Self;
-    /**
-     * Falls back to a publisher produced by `fn` when the source signals an error.
-     *
-     * Unlike {@link onErrorReturn} (which takes a static replacement), this operator
-     * calls `fn` with the actual error, allowing dynamic recovery based on the error type.
-     *
-     * @param fn - Called with the error; returns the replacement publisher.
-     * @returns A publisher that recovers from errors dynamically.
-     *
-     * @example
-     * ```typescript
-     * Flux.error(new Error('not found'))
-     *   .onErrorResume(e => e.message === 'not found' ? Flux.just('default') : Flux.error(e))
-     *   .subscribe(v => console.log(v)); // 'default'
-     * ```
-     */
-    onErrorResume(fn: (error: Error) => Publisher<T>): Self;
-    /**
-     * Transforms the error signal using `fn` before forwarding it downstream.
-     *
-     * Useful for converting low-level errors into domain-specific error types.
-     *
-     * @param fn - Receives the original error and returns a replacement error.
-     * @returns A publisher that transforms errors before propagating them.
-     *
-     * @example
-     * ```typescript
-     * Flux.error(new Error('HTTP 404'))
-     *   .onErrorMap(e => new Error(`NotFound: ${e.message}`))
-     *   .subscribe(null, e => console.error(e.message)); // NotFound: HTTP 404
-     * ```
-     */
-    onErrorMap(fn: (error: Error) => Error): Self;
-    /**
-     * Emits a `TimeoutError` (or switches to `fallback`) if no item is received
-     * within `ms` milliseconds of the previous item (or of subscription).
-     *
-     * The timer resets on each received item, so it measures **inter-item** idle time.
-     *
-     * @param ms - Timeout duration in milliseconds.
-     * @param fallback - Optional publisher to switch to on timeout instead of erroring.
-     * @returns A publisher that errors or falls back when no item arrives in time.
-     *
-     * @example
-     * ```typescript
-     * Flux.never<number>()
-     *   .timeout(100)
-     *   .subscribe(null, e => console.error(e.message)); // TimeoutError after 100ms
-     * ```
-     */
-    timeout(ms: number, fallback?: Publisher<T>): Self;
-    /**
-     * Delays the subscription to the upstream source by `ms` milliseconds.
-     *
-     * `onSubscribe` is delivered immediately with a proxy `Subscription`.
-     * Any `request(n)` calls before the delay elapses are accumulated and
-     * forwarded once the actual subscription starts.
-     *
-     * @param ms - Delay in milliseconds before subscribing to the source.
-     * @returns A publisher whose upstream subscription is deferred.
-     */
-    delaySubscription(ms: number): Self;
-    /**
-     * Logs each reactive signal to the console for debugging.
-     *
-     * Prints `onSubscribe`, `request(n)`, `onNext(value)`, `onError`, `onComplete`,
-     * and `cancel` with an optional label prefix.
-     *
-     * @param label - Optional label prepended to each log line (default: `'reactor'`).
-     * @returns A publisher with logging side effects attached.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2).log('source').subscribe(v => console.log(v));
-     * // [source] onSubscribe
-     * // [source] request(9007199254740991)
-     * // [source] onNext(1)
-     * // ...
-     * ```
-     */
-    log(label?: string): Self;
-    /**
-     * Executes a side-effect `fn` whenever the downstream subscriber issues a `request(n)`.
-     *
-     * Useful for debugging backpressure — see exactly how much demand is flowing upstream.
-     * Any exception thrown by `fn` is silently swallowed.
-     *
-     * @param fn - Called with the requested count `n`.
-     * @returns A publisher with the side effect attached to the request signal.
-     */
-    doOnRequest(fn: (n: number) => void): Self;
-    /**
-     * Executes a side-effect `fn` for every reactive signal (next, error, complete).
-     *
-     * The {@link Signal} discriminated union lets you inspect the kind and payload
-     * of each event in a single callback.
-     *
-     * @param fn - Called for every signal with a {@link Signal} wrapper.
-     * @returns A publisher with the side effect attached to all signals.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2)
-     *   .doOnEach(s => { if (s.kind === 'next') console.log('item:', s.value); })
-     *   .subscribe();
-     * ```
-     */
-    doOnEach(fn: (signal: Signal<T>) => void): Self;
-    /**
-     * Shifts the *subscription* (and source execution) to the given `scheduler`.
-     *
-     * The actual call to `this.source.subscribe(...)` is deferred and run on `scheduler`.
-     * Downstream `onSubscribe` is delivered immediately on the calling thread with a proxy
-     * `Subscription` that buffers `request(n)` calls until the source subscription is ready.
-     *
-     * Use this for cold sources that do their work synchronously on subscribe — it moves
-     * that work to a different thread/context.
-     *
-     * @param scheduler - The scheduler on which the source is subscribed to and runs.
-     * @returns A publisher whose source execution runs on the given scheduler.
-     */
-    subscribeOn(scheduler: Scheduler): Self;
-}
-
-/**
- * Backpressure-aware push interface handed to the generator function of {@link Flux.create}.
- *
- * Extends {@link Sink} with demand tracking and lifecycle hooks so the producer
- * can react to downstream request signals and cancellation. The generator may call
- * `next`, `error`, and `complete` freely from any context (event listener, timer,
- * callback). Items pushed when downstream demand is zero are buffered and delivered
- * as soon as demand becomes available.
- *
- * @typeParam T - The type of items to push.
- */
-interface FluxSink<T> extends Sink<T> {
-    /**
-     * Push the next value. Buffered if downstream has no outstanding demand.
-     * No-op after `complete()` or `error()` have been called.
-     */
-    next(value: T): void;
-    /**
-     * Terminate the stream with an error.
-     * No-op if the sink has already terminated.
-     */
-    error(error: Error): void;
-    /**
-     * Complete the stream normally.
-     * No-op if the sink has already terminated.
-     */
-    complete(): void;
-    /**
-     * The current downstream demand (number of items the subscriber has requested
-     * but not yet received). Useful for push-pull hybrid sources.
-     */
-    readonly requested: number;
-    /**
-     * Register a callback that is called each time downstream requests more items.
-     * Multiple callbacks may be registered; they are all called in registration order.
-     * @param fn - Called with the additional demand count.
-     * @returns `this` for chaining.
-     */
-    onRequest(fn: (n: number) => void): FluxSink<T>;
-    /**
-     * Register a callback that is called when downstream cancels (unsubscribes).
-     * @param fn - Cancellation handler.
-     * @returns `this` for chaining.
-     */
-    onCancel(fn: () => void): FluxSink<T>;
-    /**
-     * Register a callback that is called when the sink is disposed —
-     * either by cancellation or terminal signal.
-     * @param fn - Disposal handler.
-     * @returns `this` for chaining.
-     */
-    onDispose(fn: () => void): FluxSink<T>;
-}
-
-/**
- * Minimal interface compatible with the browser `WebSocket` API and the `ws` npm package.
- *
- * Any object that exposes `onmessage`, `onerror`, `onclose`, and `close()` satisfies
- * this interface and can be passed to {@link Flux.fromWebSocket}.
- *
- * @typeParam T - The type of `event.data` received in each message.
- */
-interface WebSocketLike<T = unknown> {
-    /** Assigned when a message arrives; `event.data` carries the payload. */
-    onmessage: ((event: {
-        data: T;
-    }) => void) | null;
-    /** Assigned when a transport-level error occurs. */
-    onerror: ((event: unknown) => void) | null;
-    /** Assigned when the connection is closed. */
-    onclose: ((event: {
-        code: number;
-        reason: string | Buffer;
-    }) => void) | null;
-    /** Close the connection, optionally with a status code and reason. */
-    close(code?: number, reason?: string | Buffer): void;
-    /** Current connection state (0 = CONNECTING, 1 = OPEN, 2 = CLOSING, 3 = CLOSED). */
-    readonly readyState: number;
-}
-/**
- * Minimal DOM-style event target interface (`addEventListener` / `removeEventListener`).
- * Satisfied by browser `EventTarget`, `HTMLElement`, `window`, `document`, etc.
- *
- * @typeParam T - The event type emitted by the target.
- */
-interface DOMEventTargetLike<T = Event> {
-    addEventListener(type: string, listener: (event: T) => void): void;
-    removeEventListener(type: string, listener: (event: T) => void): void;
-}
-/**
- * Minimal Node.js-style event emitter interface (`on` / `off`).
- * Satisfied by Node.js `EventEmitter` and any object with the same shape.
- *
- * @typeParam T - The event data type emitted by the emitter.
- */
-interface NodeEventEmitterLike<T = unknown> {
-    on(event: string | symbol, listener: (data: T) => void): void;
-    off(event: string | symbol, listener: (data: T) => void): void;
-}
-/**
- * Union of {@link DOMEventTargetLike} and {@link NodeEventEmitterLike}.
- * Accepted by {@link Flux.fromEvent}.
- */
-type EventSourceLike<T = unknown> = DOMEventTargetLike<T> | NodeEventEmitterLike<T>;
-/**
- * A cold publisher of 0 to N items with full backpressure support.
- *
- * Items flow only when the downstream {@link Subscription} issues `request(n)`.
- * The convenience `subscribe(onNext, onError, onComplete)` overloads
- * automatically request `Number.MAX_SAFE_INTEGER` so items start arriving
- * without extra ceremony.
- *
- * Each `subscribe()` call creates an **independent** run of the pipeline
- * ("cold" semantics). Use {@link Flux.cache} or {@link Sinks} to share a
- * single run across multiple subscribers.
- *
- * @typeParam T - The type of items emitted by this Flux.
- *
- * @example
- * ```typescript
- * Flux.just(1, 2, 3)
- *   .map(n => n * 2)
- *   .filter(n => n > 2)
- *   .subscribe(v => console.log(v));
- * // 4  6
- * ```
- */
-declare class Flux<T> extends AbstractPipePublisher<T, Flux<T>> implements PipePublisher<T> {
-    protected constructor(source: Publisher<T>);
-    protected defaultDemand(): number;
-    protected wrapSource(source: Publisher<T>): Flux<T>;
-    /**
-     * Wraps an existing {@link Publisher} as a `Flux`.
-     *
-     * @param publisher - Any `Publisher<T>` to adapt.
-     * @returns A `Flux<T>` backed by the given publisher.
-     */
-    static from<T>(publisher: Publisher<T>): Flux<T>;
-    /**
-     * Creates a `Flux` from a generator function that pushes values imperatively.
-     *
-     * The generator receives a {@link Sink} and may call `sink.next(v)` any number
-     * of times, then `sink.complete()` or `sink.error(e)`.  Delivery is
-     * **backpressure-aware**: items pushed when demand is zero are buffered and
-     * delivered as downstream issues `request(n)`.
-     *
-     * Rule 1.3 is respected — `onSubscribe` is delivered to the subscriber
-     * **before** the generator runs.
-     *
-     * @param generator - Function that pushes items via the provided `Sink<T>`.
-     * @returns A cold `Flux<T>`.
-     *
-     * @example
-     * ```typescript
-     * Flux.generate<number>(sink => {
-     *   sink.next(1);
-     *   sink.next(2);
-     *   sink.complete();
-     * }).subscribe(v => console.log(v)); // 1  2
-     * ```
-     */
-    static generate<T>(generator: (sink: Sink<T>) => void): Flux<T>;
-    /**
-     * Creates a `Flux` that emits every element of an `Iterable` in order, then completes.
-     *
-     * @param iterable - Any `Iterable<T>` (Array, Set, Map, generator, etc.).
-     * @returns A cold `Flux<T>`.
-     *
-     * @example
-     * ```typescript
-     * Flux.fromIterable(['a', 'b', 'c']).subscribe(v => console.log(v));
-     * // a  b  c
-     * ```
-     */
-    static fromIterable<T>(iterable: Iterable<T>): Flux<T>;
-    /**
-     * Creates a `Flux` that emits `count` sequential integers starting at `start`.
-     *
-     * @param start - First integer to emit.
-     * @param count - Number of integers to emit.
-     * @returns A cold `Flux<number>` emitting `[start, start + count)`.
-     *
-     * @example
-     * ```typescript
-     * Flux.range(0, 5).subscribe(v => console.log(v)); // 0 1 2 3 4
-     * ```
-     */
-    static range(start: number, count: number): Flux<number>;
-    /**
-     * Creates a `Flux` that completes immediately without emitting any items.
-     *
-     * @returns An empty, completed `Flux<T>`.
-     */
-    static empty<T = never>(): Flux<T>;
-    /**
-     * Lazily creates a new `Flux` per subscription by calling `factory`.
-     *
-     * Useful when the source depends on mutable state that should be captured
-     * at subscribe time rather than at assembly time.
-     *
-     * @param factory - Called once per subscription to produce the actual `Flux<T>`.
-     * @returns A lazy `Flux<T>`.
-     */
-    static defer<T>(factory: () => Flux<T>): Flux<T>;
-    /**
-     * Creates a `Flux` that emits the provided items in order, then completes.
-     *
-     * @param items - Zero or more items to emit.
-     * @returns A cold `Flux<T>`.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2, 3).subscribe(v => console.log(v)); // 1  2  3
-     * ```
-     */
-    static just<T>(...items: T[]): Flux<T>;
-    /**
-     * Creates a `Flux` that signals `onError` immediately upon subscription.
-     *
-     * @param error - The error to signal.
-     * @returns An errored `Flux<T>`.
-     */
-    static error<T = never>(error: Error): Flux<T>;
-    /**
-     * Creates a `Flux` that never emits any signal — no items, no error, no completion.
-     * Useful as a placeholder or to represent an infinite, empty stream.
-     *
-     * @returns A `Flux<T>` that stays subscribed forever.
-     */
-    static never<T = never>(): Flux<T>;
-    /**
-     * Creates a `Flux` from a generator function that **pushes** values imperatively
-     * via a {@link FluxSink}.
-     *
-     * Unlike {@link Flux.generate} (which is request-pull), `create` is designed for
-     * **push-based** sources (EventEmitter, WebSocket, DOM events, Node.js streams).
-     * Items pushed when downstream demand is zero are **buffered** and delivered as demand
-     * becomes available.
-     *
-     * Register `onRequest`, `onCancel`, and `onDispose` callbacks on the sink to respond
-     * to downstream lifecycle events.
-     *
-     * @param emitter - Called once per subscription; receives a `FluxSink<T>` for pushing values.
-     * @returns A cold `Flux<T>`.
-     *
-     * @example
-     * ```typescript
-     * const emitter = new EventEmitter();
-     * const flux = Flux.create<string>(sink => {
-     *   emitter.on('data', v => sink.next(v));
-     *   emitter.on('end',  () => sink.complete());
-     *   sink.onCancel(() => emitter.removeAllListeners());
-     * });
-     * ```
-     */
-    static create<T>(emitter: (sink: FluxSink<T>) => void): Flux<T>;
-    /**
-     * Creates a `Flux` that acquires a resource, uses it to build a source publisher,
-     * and guarantees the resource is cleaned up when the stream terminates or is cancelled.
-     *
-     * The cleanup runs after `onComplete`, `onError`, or `unsubscribe()` — whichever
-     * happens first.
-     *
-     * @param resourceSupplier - Called once per subscription to acquire the resource.
-     * @param sourceFactory - Builds the source publisher from the resource.
-     * @param cleanup - Called with the resource after the stream terminates.
-     * @returns A `Flux<T>` with guaranteed resource cleanup.
-     *
-     * @example
-     * ```typescript
-     * Flux.using(
-     *   () => openFile('data.txt'),
-     *   file => Flux.fromIterable(file.readLines()),
-     *   file => file.close()
-     * ).subscribe(line => console.log(line));
-     * ```
-     */
-    static using<T, R>(resourceSupplier: () => R, sourceFactory: (resource: R) => Publisher<T>, cleanup: (resource: R) => void): Flux<T>;
-    /**
-     * Creates a `Flux<T>` that emits each message received on a `WebSocket`.
-     *
-     * - Each message's `data` is emitted as the next item.
-     * - The stream **completes** when the socket is closed (any close code).
-     * - A transport-level error event terminates the stream with an `Error`.
-     * - **Unsubscribing** closes the socket gracefully (sends a normal-closure frame).
-     *
-     * Compatible with the browser `WebSocket` API and the `ws` npm package. Any object
-     * satisfying the {@link WebSocketLike} interface can be passed.
-     *
-     * @param ws - An open (or opening) WebSocket instance.
-     * @returns A `Flux<T>` backed by the WebSocket message stream.
-     *
-     * @example
-     * ```typescript
-     * // Browser
-     * Flux.fromWebSocket<string>(new WebSocket('wss://example.com/chat'))
-     *   .map(msg => JSON.parse(msg))
-     *   .subscribe(msg => console.log(msg));
-     *
-     * // Node.js (ws package)
-     * import WebSocket from 'ws';
-     * Flux.fromWebSocket<Buffer>(new WebSocket('ws://localhost:8080'))
-     *   .map(buf => buf.toString())
-     *   .subscribe(text => console.log(text));
-     * ```
-     */
-    static fromWebSocket<T = unknown>(ws: WebSocketLike<T>): Flux<T>;
-    /**
-     * Creates an infinite `Flux<T>` that emits every event of type `eventName` fired on
-     * `target`. The stream never completes on its own — call `unsubscribe()` or chain a
-     * limiting operator (e.g. `.take(n)`, `.takeUntilOther(stop$)`) to terminate it.
-     *
-     * Works with:
-     * - **DOM targets** (`EventTarget`: `HTMLElement`, `window`, `document`, …) — uses
-     *   `addEventListener` / `removeEventListener`.
-     * - **Node.js emitters** (any object with `on` / `off`) — uses those methods directly.
-     *
-     * Events fired while downstream has no demand are **buffered** (via {@link Flux.create})
-     * and delivered once demand is available.
-     *
-     * @param target - A DOM `EventTarget` or Node.js-style event emitter.
-     * @param eventName - The event name / type to listen for.
-     * @returns An infinite cold `Flux<T>` of matching events.
-     *
-     * @example
-     * ```typescript
-     * // Browser — click events on a button
-     * Flux.fromEvent<MouseEvent>(document.getElementById('btn')!, 'click')
-     *   .map(e => ({ x: e.clientX, y: e.clientY }))
-     *   .subscribe(pos => console.log(pos));
-     *
-     * // Node.js EventEmitter
-     * import { EventEmitter } from 'events';
-     * const emitter = new EventEmitter();
-     * Flux.fromEvent<string>(emitter, 'data')
-     *   .take(5)
-     *   .subscribe(v => console.log(v));
-     * ```
-     */
-    static fromEvent<T = Event>(target: EventSourceLike<T>, eventName: string): Flux<T>;
-    /**
-     * Merges N publishers by subscribing to all of them concurrently and interleaving
-     * their items as they arrive.
-     *
-     * The stream completes when **all** sources complete.
-     * Any error from any source terminates the merged stream immediately.
-     *
-     * @param sources - Publishers to merge.
-     * @returns A `Flux<T>` that emits items from all sources concurrently.
-     *
-     * @example
-     * ```typescript
-     * Flux.merge(Flux.just(1, 2), Flux.just(3, 4)).subscribe(v => console.log(v));
-     * // 1 2 3 4 (order may vary for async sources)
-     * ```
-     */
-    static merge<T>(...sources: Publisher<T>[]): Flux<T>;
-    /**
-     * Subscribes to all `sources` concurrently and emits the **first value** produced
-     * by any of them. All other subscriptions are cancelled immediately after the winner emits.
-     *
-     * If all sources complete without emitting a value, the result completes empty.
-     * Errors from non-winning sources are ignored once a winner is found.
-     *
-     * @param sources - Publishers to race.
-     * @returns A `Flux<T>` that emits the first value from any source.
-     *
-     * @example
-     * ```typescript
-     * // Take whichever request responds first
-     * Flux.firstWithValue(fetchFromCDN(), fetchFromOrigin())
-     *   .subscribe(data => console.log(data));
-     * ```
-     */
-    static firstWithValue<T>(...sources: Publisher<T>[]): Flux<T>;
-    /**
-     * Emits an ever-incrementing counter (0, 1, 2, …) at a fixed `ms` rate.
-     *
-     * Items are **dropped** when downstream has no outstanding demand (rather than
-     * buffered), matching Reactor's `Flux.interval` drop-on-overflow behaviour.
-     * The stream never completes on its own — cancel the subscription to stop it.
-     *
-     * @param ms - Interval duration in milliseconds.
-     * @returns An infinite `Flux<number>`.
-     *
-     * @example
-     * ```typescript
-     * Flux.interval(1000).take(3).subscribe(n => console.log(n)); // 0  1  2
-     * ```
-     */
-    static interval(ms: number): Flux<number>;
-    /**
-     * Combines items from 2 sources positionally via `combiner`.
-     * Emits one combined value for each position; stops when the shorter source exhausts.
-     */
-    static zip<A, B, R>(sources: [Publisher<A>, Publisher<B>], combiner: (a: A, b: B) => R): Flux<R>;
-    /**
-     * Combines items from 3 sources positionally via `combiner`.
-     */
-    static zip<A, B, C, R>(sources: [Publisher<A>, Publisher<B>, Publisher<C>], combiner: (a: A, b: B, c: C) => R): Flux<R>;
-    /**
-     * Combines items from 4 sources positionally via `combiner`.
-     */
-    static zip<A, B, C, D, R>(sources: [Publisher<A>, Publisher<B>, Publisher<C>, Publisher<D>], combiner: (a: A, b: B, c: C, d: D) => R): Flux<R>;
-    /**
-     * General N-source positional zip.
-     *
-     * Subscribes to each source concurrently, using a prefetch of 1 per source.
-     * Once every source has provided one item for a given position, `combiner` is
-     * called with those items and the result is emitted downstream.  The stream
-     * completes when any source completes and has no buffered items left.
-     *
-     * @param sources - Publishers to zip.
-     * @param combiner - Combines one item from each source at the same position.
-     * @returns A `Flux<R>` of combined values.
-     *
-     * @example
-     * ```typescript
-     * Flux.zip([Flux.just(1, 2), Flux.just('a', 'b')], (n, s) => `${n}${s}`)
-     *   .subscribe(v => console.log(v)); // '1a'  '2b'
-     * ```
-     */
-    static zip<T, R>(sources: Publisher<T>[], combiner: (...args: T[]) => R): Flux<R>;
-    /**
-     * Combines the **latest** value from each source whenever any source emits.
-     *
-     * Does not emit until all sources have produced at least one value.
-     * Continues emitting with each new item from any source, using the latest values
-     * from all others.  Sources run at unbounded speed; downstream demand controls delivery.
-     *
-     * @param sources - Publishers to combine.
-     * @param combiner - Called with the latest value from each source.
-     * @returns A `Flux<R>` of combined values.
-     *
-     * @example
-     * ```typescript
-     * Flux.combineLatest([Flux.just(1, 2), Flux.just('a', 'b')], (n, s) => `${n}${s}`)
-     *   .subscribe(v => console.log(v)); // '1a'  '2a'  '2b'  (order depends on timing)
-     * ```
-     */
-    static combineLatest<A, B, R>(sources: [Publisher<A>, Publisher<B>], combiner: (a: A, b: B) => R): Flux<R>;
-    static combineLatest<A, B, C, R>(sources: [Publisher<A>, Publisher<B>, Publisher<C>], combiner: (a: A, b: B, c: C) => R): Flux<R>;
-    static combineLatest<A, B, C, D, R>(sources: [Publisher<A>, Publisher<B>, Publisher<C>, Publisher<D>], combiner: (a: A, b: B, c: C, d: D) => R): Flux<R>;
-    static combineLatest<T, R>(sources: Publisher<T>[], combiner: (...args: T[]) => R): Flux<R>;
-    /**
-     * Transforms each item using `fn`, producing a `Flux<R>`.
-     *
-     * If `fn` throws, the exception is forwarded to `onError` and the stream terminates.
-     *
-     * @param fn - Mapping function applied to every item.
-     * @returns A new `Flux<R>`.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2, 3).map(n => n * 10).subscribe(v => console.log(v));
-     * // 10  20  30
-     * ```
-     */
-    map<R>(fn: (value: T) => R): Flux<R>;
-    /**
-     * Transforms each item with `fn`, silently discarding `null`/`undefined` results.
-     *
-     * When an item is discarded, upstream demand is replenished by 1 so the
-     * downstream demand accounting stays correct.
-     *
-     * @param fn - Mapping function; returning `null` or `undefined` skips the item.
-     * @returns A `Flux<NonNullable<R>>` with nulls filtered out.
-     *
-     * @example
-     * ```typescript
-     * Flux.just('hello', '', 'world')
-     *   .mapNotNull(s => s.length > 0 ? s : null)
-     *   .subscribe(v => console.log(v));
-     * // hello  world
-     * ```
-     */
-    mapNotNull<R>(fn: (value: T) => R | null | undefined): Flux<NonNullable<R>>;
-    /**
-     * Fine-grained per-item transform: the `handler` receives each item together with
-     * a {@link Sink} and may emit **0 or 1** result items.
-     *
-     * - Calling `sink.next(r)` once emits `r` downstream.
-     * - Calling `sink.next(r)` more than once is silently ignored (0-or-1 semantics).
-     * - Calling `sink.complete()` or `sink.error(e)` terminates the stream early.
-     * - If the handler emits nothing (0 items), upstream demand is replenished by 1.
-     *
-     * This is the Flux equivalent of `reactor-core`'s `handle(BiConsumer<T, SynchronousSink<R>>)`.
-     *
-     * @param handler - Called for each upstream item with the item and an output `Sink<R>`.
-     * @returns A `Flux<R>`.
-     *
-     * @example
-     * ```typescript
-     * // Convert strings to numbers, skip non-numeric entries
-     * Flux.just('1', 'two', '3').handle<number>((s, sink) => {
-     *   const n = parseInt(s);
-     *   if (!isNaN(n)) sink.next(n);
-     * }).subscribe(v => console.log(v));
-     * // 1  3
-     * ```
-     */
-    handle<R>(handler: (value: T, sink: Sink<R>) => void): Flux<R>;
-    /**
-     * Maps each item to an inner publisher and merges all inner publishers concurrently
-     * into a single `Flux<R>` (**merge** semantics).
-     *
-     * Inner publishers are subscribed to as soon as their corresponding outer item arrives.
-     * Items from different inner publishers can interleave. The resulting stream completes
-     * when the outer source completes **and** all inner publishers complete. Any error
-     * (from outer or any inner) immediately terminates the stream.
-     *
-     * @param fn - Maps each item to a `Flux<R>`, `Mono<R>`, or any `Publisher<R>`.
-     * @returns A merged `Flux<R>`.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2, 3)
-     *   .flatMap(n => Mono.just(n * 10))
-     *   .subscribe(v => console.log(v));
-     * // 10  20  30  (order may vary with async inner publishers)
-     * ```
-     */
-    flatMap<R>(fn: (value: T) => Flux<R>): Flux<R>;
-    flatMap<R>(fn: (value: T) => Mono<R>): Flux<R>;
-    flatMap<R>(fn: (value: T) => Publisher<R>): Flux<R>;
-    /**
-     * Maps each item to an inner publisher and subscribes to them **sequentially**,
-     * preserving order (**concat** semantics).
-     *
-     * The next inner publisher is subscribed to only after the previous one completes.
-     * This guarantees item ordering but has no concurrency.
-     *
-     * @param fn - Maps each item to a `Flux<R>`, `Mono<R>`, or any `Publisher<R>`.
-     * @returns An ordered, sequential `Flux<R>`.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2, 3)
-     *   .concatMap(n => Mono.just(`item-${n}`))
-     *   .subscribe(v => console.log(v));
-     * // item-1  item-2  item-3
-     * ```
-     */
-    concatMap<R>(fn: (value: T) => Flux<R>): Flux<R>;
-    concatMap<R>(fn: (value: T) => Mono<R>): Flux<R>;
-    concatMap<R>(fn: (value: T) => Publisher<R>): Flux<R>;
-    /**
-     * Maps each item to an inner publisher, **cancelling** the previous inner subscription
-     * whenever a new outer item arrives (**switch** semantics).
-     *
-     * Only the most recently started inner publisher is active at any point. This is
-     * useful for patterns like "search as you type" where stale results should be
-     * discarded when a newer request supersedes them.
-     *
-     * @param fn - Maps each item to a `Flux<R>`, `Mono<R>`, or any `Publisher<R>`.
-     * @returns A `Flux<R>` that tracks only the latest inner publisher.
-     */
-    switchMap<R>(fn: (value: T) => Flux<R>): Flux<R>;
-    switchMap<R>(fn: (value: T) => Mono<R>): Flux<R>;
-    switchMap<R>(fn: (value: T) => Publisher<R>): Flux<R>;
-    /**
-     * Passes only items for which `predicate` returns `true`.
-     *
-     * Each dropped item replenishes upstream demand by 1 to keep the total
-     * outstanding demand accurate.
-     *
-     * @param predicate - Synchronous test applied to each item.
-     * @returns A filtered `Flux<T>`.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2, 3, 4).filter(n => n % 2 === 0).subscribe(v => console.log(v));
-     * // 2  4
-     * ```
-     */
-    filter(predicate: (value: T) => boolean): Flux<T>;
-    /**
-     * Asynchronous filter: for each item, subscribes to `predicate(item)` and forwards
-     * the item downstream only if the predicate publisher emits `true`.
-     *
-     * Implemented via {@link concatMap} — predicates run sequentially.
-     *
-     * @param predicate - Returns a `Publisher<boolean>` for each item.
-     * @returns A filtered `Flux<T>`.
-     */
-    filterWhen(predicate: (value: T) => Publisher<boolean>): Flux<T>;
-    /**
-     * Unsafe type cast — changes the declared element type to `R` without any
-     * runtime conversion.  Use only when you are certain the actual runtime
-     * type is compatible.
-     *
-     * @typeParam R - The target element type.
-     * @returns This `Flux` re-typed as `Flux<R>`.
-     */
-    cast<R>(): Flux<R>;
-    /**
-     * Emits at most `n` items, then cancels the upstream subscription and completes.
-     *
-     * If `n ≤ 0`, returns an empty `Flux` immediately.
-     *
-     * @param n - Maximum number of items to emit.
-     * @returns A bounded `Flux<T>`.
-     */
-    take(n: number): Flux<T>;
-    /**
-     * Emits items while `predicate(item)` returns `true`.
-     * Completes (and cancels upstream) on the first item for which it returns `false`.
-     *
-     * @param predicate - Tested synchronously for each item.
-     * @returns A `Flux<T>` that stops on the first `false`.
-     */
-    takeWhile(predicate: (value: T) => boolean): Flux<T>;
-    /**
-     * Forwards items from this `Flux` until `trigger` emits its first item (or completes),
-     * then cancels the source and completes downstream.
-     *
-     * If `trigger` signals an error, that error is forwarded to the subscriber.
-     *
-     * @param trigger - A `Publisher` whose first emission ends this stream.
-     * @returns A `Flux<T>` that stops when the trigger fires.
-     */
-    takeUntilOther(trigger: Publisher<unknown>): Flux<T>;
-    /** Emit defaultValue if source completes without emitting any item. */
-    /**
-     * Emits `value` if the source completes without having emitted any items,
-     * then completes.  If the source does emit items, they pass through unchanged.
-     *
-     * @param value - Fallback item to emit when the source is empty.
-     * @returns A `Flux<T>` that is never empty.
-     */
-    defaultIfEmpty(value: T): Flux<T>;
-    /**
-     * Re-subscribes to the source on `onError`, up to `maxRetries` times.
-     *
-     * Accumulated downstream demand from previous attempts is preserved across retries.
-     * If the error persists after all retries are exhausted, it is forwarded to downstream.
-     *
-     * @param maxRetries - Maximum number of retry attempts (default: `Number.MAX_SAFE_INTEGER`).
-     * @returns A `Flux<T>` with automatic retry on error.
-     */
-    retry(maxRetries?: number): Flux<T>;
-    /**
-     * Emits a running accumulation of the stream.
-     *
-     * The first item is emitted as-is and becomes the initial accumulator.
-     * Each subsequent item is combined with the running accumulator using `reducer`,
-     * and the result is emitted downstream.
-     *
-     * @param reducer - Combines the running accumulator with the next item.
-     * @returns A `Flux<T>` of intermediate accumulation results.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2, 3, 4).scan((acc, n) => acc + n).subscribe(v => console.log(v));
-     * // 1  3  6  10
-     * ```
-     */
-    scan(reducer: (acc: T, next: T) => T): Flux<T>;
-    /**
-     * Emits a running accumulation of the stream with an explicit seed value.
-     *
-     * `seedFactory` is called once per subscription to produce the initial accumulator.
-     * Each upstream item is folded into the accumulator and the intermediate result is
-     * emitted downstream.
-     *
-     * @param seedFactory - Called per subscription to produce the initial accumulator of type `A`.
-     * @param reducer - Combines the current accumulator with the next item.
-     * @returns A `Flux<A>` of intermediate accumulation results.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2, 3).scanWith(() => 0, (acc, n) => acc + n).subscribe(v => console.log(v));
-     * // 1  3  6
-     * ```
-     */
-    scanWith<A>(seedFactory: () => A, reducer: (acc: A, next: T) => A): Flux<A>;
-    /**
-     * Pair-wise combines items from this `Flux` and `other` using `combiner`.
-     *
-     * Items are matched by position: the first item from each source is combined, then the second, etc.
-     * The stream completes when either source completes. If either source errors, the error is forwarded.
-     *
-     * @param other - The second publisher to zip with.
-     * @param combiner - Combines one item from each source into a result item.
-     * @returns A `Flux<V>` of combined pairs.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2, 3)
-     *   .zipWith(Flux.just('a', 'b', 'c'), (n, s) => `${n}${s}`)
-     *   .subscribe(v => console.log(v));
-     * // 1a  2b  3c
-     * ```
-     */
-    zipWith<R, V>(other: Publisher<R>, combiner: (a: T, b: R) => V): Flux<V>;
-    /**
-     * Executes a side-effect function when the source completes normally.
-     *
-     * The function runs just before `onComplete` is forwarded to the downstream subscriber.
-     * Any exception thrown by `fn` is silently swallowed.
-     *
-     * @param fn - Side-effect to run on normal completion.
-     * @returns A `Flux<T>` with the side effect attached.
-     */
-    doOnComplete(fn: () => void): Flux<T>;
-    /**
-     * Executes a side-effect function when the source terminates — either normally (`onComplete`)
-     * or with an error (`onError`).
-     *
-     * The function runs before the terminal signal is forwarded downstream.
-     * Any exception thrown by `fn` is silently swallowed.
-     *
-     * @param fn - Side-effect to run on any terminal signal.
-     * @returns A `Flux<T>` with the side effect attached.
-     */
-    doOnTerminate(fn: () => void): Flux<T>;
-    /**
-     * Executes a side-effect function when the downstream subscriber cancels
-     * (calls `unsubscribe()`).
-     *
-     * Any exception thrown by `fn` is silently swallowed.
-     *
-     * @param fn - Side-effect to run on cancellation.
-     * @returns A `Flux<T>` with the side effect attached.
-     */
-    doOnCancel(fn: () => void): Flux<T>;
-    /**
-     * Executes a side-effect function after the stream ends for **any** reason —
-     * normal completion, error, or cancellation.
-     *
-     * Any exception thrown by `fn` is silently swallowed.
-     *
-     * @param fn - Side-effect to run after any terminal event or cancellation.
-     * @returns A `Flux<T>` with the side effect attached.
-     */
-    doFinally(fn: () => void): Flux<T>;
-    /**
-     * Low-level escape hatch for bridging imperative push-based sources.
-     *
-     * The `producer` receives three callbacks and must call them to drive the stream.
-     * `onRequest` and `onUnsubscribe` let the caller respond to downstream demand and
-     * cancellation respectively.
-     *
-     * @param producer - Callback that receives `(onNext, onError, onComplete)` and drives the stream.
-     * @param onRequest - Called when the downstream subscriber requests `n` more items.
-     * @param onUnsubscribe - Called when the downstream subscriber cancels.
-     * @returns A `Flux<R>` backed by the imperative producer.
-     */
-    pipe<R>(producer: (onNext: (value: R) => void, onError: (error: Error) => void, onComplete: () => void) => void, onRequest: (request: number) => void, onUnsubscribe: () => void): Flux<R>;
-    /**
-     * Returns the first item of this `Flux` as a `Mono`.
-     *
-     * If the source is empty, the resulting `Mono` completes without emitting a value.
-     * The source subscription is cancelled immediately after the first item is received.
-     *
-     * @returns A `Mono<T>` that emits the first item, or completes empty.
-     */
-    first(): Mono<T>;
-    /**
-     * Returns the last item of this `Flux` as a `Mono`.
-     *
-     * The source is fully consumed before the value is emitted.
-     * If the source is empty, the resulting `Mono` completes without emitting a value.
-     *
-     * @returns A `Mono<T>` that emits the last item, or completes empty.
-     */
-    last(): Mono<T>;
-    /**
-     * Counts all items emitted by this `Flux` and emits the total as a `Mono<number>`.
-     *
-     * The source is fully consumed before the count is emitted.
-     *
-     * @returns A `Mono<number>` emitting the number of items.
-     */
-    count(): Mono<number>;
-    /**
-     * Emits `true` if this `Flux` emits at least one item, `false` if it completes empty.
-     *
-     * The source subscription is cancelled as soon as the first item is observed.
-     *
-     * @returns A `Mono<boolean>`.
-     */
-    hasElements(): Mono<boolean>;
-    /**
-     * Emits `true` if any item matches `predicate`, `false` if none do.
-     *
-     * Short-circuits: cancels the source and emits `true` on the first matching item.
-     * If `predicate` throws, the error is forwarded to the subscriber.
-     *
-     * @param predicate - Test applied to each item.
-     * @returns A `Mono<boolean>`.
-     */
-    any(predicate: (value: T) => boolean): Mono<boolean>;
-    /**
-     * Emits `true` if every item matches `predicate`, `false` if any item does not.
-     *
-     * Short-circuits: cancels the source and emits `false` on the first non-matching item.
-     * If `predicate` throws, the error is forwarded to the subscriber.
-     *
-     * @param predicate - Test applied to each item.
-     * @returns A `Mono<boolean>`.
-     */
-    all(predicate: (value: T) => boolean): Mono<boolean>;
-    /**
-     * Emits `true` if no item matches `predicate`, `false` if any item does.
-     *
-     * This is the logical negation of {@link any}.
-     *
-     * @param predicate - Test applied to each item.
-     * @returns A `Mono<boolean>`.
-     */
-    none(predicate: (value: T) => boolean): Mono<boolean>;
-    /**
-     * Returns the item at zero-based `index` as a `Mono<T>`.
-     *
-     * If the source completes before reaching `index`, emits `defaultValue` if provided,
-     * otherwise completes empty.
-     *
-     * @param index - Zero-based position of the desired item.
-     * @param defaultValue - Optional fallback value emitted if the index is out of range.
-     * @returns A `Mono<T>`.
-     */
-    elementAt(index: number, defaultValue?: T): Mono<T>;
-    /**
-     * Collects all items into an array and emits the complete array as a `Mono<T[]>`.
-     *
-     * The source is fully consumed before the array is emitted.
-     *
-     * @returns A `Mono<T[]>` containing all emitted items.
-     */
-    collect(_force?: boolean): Mono<T[]>;
-    /**
-     * Alias for {@link collect}.
-     *
-     * @returns A `Mono<T[]>` containing all emitted items.
-     */
-    collectList(): Mono<T[]>;
-    /**
-     * Collects all items, sorts them, and re-emits them as a `Flux<T>`.
-     *
-     * Uses the native `Array.sort` algorithm. When no `comparator` is provided the
-     * default lexicographic sort order is used.
-     *
-     * @param comparator - Optional comparison function (same signature as `Array.sort`).
-     * @returns A `Flux<T>` that emits items in sorted order after the source completes.
-     */
-    sort(comparator?: (a: T, b: T) => number): Flux<T>;
-    /**
-     * Collects items into fixed-size arrays and emits each batch as a `T[]`.
-     *
-     * A batch is emitted as soon as it reaches `maxSize` items.
-     * The final (potentially partial) batch is emitted when the source completes.
-     *
-     * @param maxSize - Maximum number of items per batch.
-     * @returns A `Flux<T[]>` of item batches.
-     *
-     * @example
-     * ```typescript
-     * Flux.range(1, 5).buffer(2).subscribe(v => console.log(v));
-     * // [1, 2]  [3, 4]  [5]
-     * ```
-     */
-    buffer(maxSize: number): Flux<T[]>;
-    /**
-     * Caches all emitted items and replays them to each new subscriber.
-     *
-     * The source is subscribed to on the **first** downstream subscription (lazy connect).
-     * Subsequent subscribers receive a replay of all previously emitted items from the cache.
-     *
-     * @returns A cached, replayable `Flux<T>`.
-     */
-    cache(): Flux<T>;
-    /**
-     * Multicasts this `Flux` to all current subscribers using a refCounting strategy.
-     *
-     * The upstream is subscribed to when the **first** subscriber joins and cancelled
-     * when the **last** subscriber leaves. If a new subscriber arrives after all others
-     * have cancelled, a fresh upstream subscription is created.
-     *
-     * Items are delivered on a best-effort basis: a subscriber that has no outstanding
-     * demand when an item arrives simply misses that item (no buffering). Once the upstream
-     * terminates (complete or error), the terminal signal is replayed to any future subscriber.
-     *
-     * @returns A hot `Flux<T>` that shares a single upstream subscription.
-     *
-     * @example
-     * ```typescript
-     * const shared = Flux.interval(100).share();
-     * shared.subscribe(v => console.log('A', v));
-     * setTimeout(() => shared.subscribe(v => console.log('B', v)), 250);
-     * // A 0, A 1, A 2, B 2, A 3, B 3 ...
-     * ```
-     */
-    share(): Flux<T>;
-    /**
-     * Pairs each item with its zero-based index, emitting `[index, item]` tuples.
-     *
-     * @returns A `Flux<[number, T]>` where the first element is the zero-based index.
-     *
-     * @example
-     * ```typescript
-     * Flux.just('a', 'b', 'c').indexed().subscribe(([i, v]) => console.log(i, v));
-     * // 0 a  1 b  2 c
-     * ```
-     */
-    indexed(): Flux<[number, T]>;
-    /**
-     * Skips the first `n` items from the source, then forwards the rest.
-     *
-     * Skipped items replenish upstream demand so the overall demand accounting stays correct.
-     *
-     * @param n - Number of leading items to skip.
-     * @returns A `Flux<T>` without the first `n` items.
-     */
-    skip(n: number): Flux<T>;
-    /**
-     * Skips items while `predicate` returns `true`, then forwards all subsequent items
-     * regardless of the predicate.
-     *
-     * Skipped items replenish upstream demand. Once the predicate returns `false`, it is
-     * never evaluated again.
-     *
-     * @param predicate - Tested against each item until it returns `false`.
-     * @returns A `Flux<T>` that starts forwarding items after the first predicate failure.
-     */
-    skipWhile(predicate: (value: T) => boolean): Flux<T>;
-    /**
-     * Gates items from this `Flux` until `other` emits its first item.
-     *
-     * Items arriving before the gate opens are silently dropped (demand is replenished).
-     * If `other` signals an error, the error is forwarded to downstream.
-     *
-     * @param other - A `Publisher` whose first emission opens the gate.
-     * @returns A `Flux<T>` that starts forwarding items once `other` emits.
-     */
-    skipUntil(other: Publisher<unknown>): Flux<T>;
-    /**
-     * Filters out duplicate items, forwarding only items not seen before.
-     *
-     * Uses a `Set` with reference equality (`===`) to track seen values.
-     * Duplicates replenish upstream demand.
-     *
-     * @returns A `Flux<T>` with all duplicate items removed.
-     */
-    distinct(): Flux<T>;
-    /**
-     * Suppresses consecutive duplicate items.
-     *
-     * An item is forwarded only when it is different from the immediately preceding item
-     * as determined by `comparator`. The default comparator uses `!==`.
-     * Suppressed items replenish upstream demand.
-     *
-     * @param comparator - Returns `true` when two consecutive items are considered different
-     *                     (default: `(a, b) => a !== b`).
-     * @returns A `Flux<T>` without consecutive duplicates.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 1, 2, 2, 3).distinctUntilChanged().subscribe(v => console.log(v));
-     * // 1  2  3
-     * ```
-     */
-    distinctUntilChanged(comparator?: (a: T, b: T) => boolean): Flux<T>;
-    /**
-     * Delays the delivery of each item by `ms` milliseconds.
-     *
-     * Items are processed **one at a time**: the next item is requested from the source
-     * only after the previous delayed item has been delivered downstream.  This guarantees
-     * items are spaced at least `ms` apart and that `onComplete` fires only after the last
-     * delayed item has been delivered.
-     *
-     * Errors are forwarded immediately without delay, cancelling any pending timer.
-     *
-     * @param ms - Delay in milliseconds between consecutive item deliveries.
-     * @returns A `Flux<T>` where each item is delayed by `ms` before being forwarded.
-     */
-    delayElements(ms: number): Flux<T>;
-    /**
-     * Appends `other` to this `Flux`, subscribing to `other` only after this source completes.
-     *
-     * Items from this source are emitted first, in order.  Once this source completes,
-     * items from `other` are emitted.  If either source errors, the error is forwarded
-     * and `other` is not subscribed to.
-     *
-     * @param other - The publisher to concatenate after this source.
-     * @returns A `Flux<T>` that emits items from both sources sequentially.
-     */
-    concatWith(other: Publisher<T>): Flux<T>;
-    /**
-     * Merges this `Flux` with `other`, subscribing to both concurrently.
-     *
-     * Items from both sources are interleaved as they arrive. The resulting stream
-     * completes when **both** sources complete. Any error from either source terminates
-     * the merged stream immediately.
-     *
-     * @param other - The publisher to merge with this source.
-     * @returns A `Flux<T>` that emits items from both sources concurrently.
-     */
-    mergeWith(other: Publisher<T>): Flux<T>;
-    /**
-     * Reduces the stream to a single value using `reducer`, emitting the final result as a `Mono<T>`.
-     *
-     * The first item becomes the initial accumulator. If the source is empty, the resulting
-     * `Mono` completes without emitting a value.
-     *
-     * @param reducer - Combines the running accumulator with the next item.
-     * @returns A `Mono<T>` emitting the final reduced value.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2, 3, 4).reduce((acc, n) => acc + n).subscribe(v => console.log(v));
-     * // 10
-     * ```
-     */
-    reduce(reducer: (acc: T, next: T) => T): Mono<T>;
-    /**
-     * Reduces the stream to a single value of type `A`, using an explicit seed, and emits it as `Mono<A>`.
-     *
-     * `seedFactory` is called once per subscription to produce the initial accumulator.
-     * Unlike {@link reduce}, this always emits a value even if the source is empty (the seed).
-     *
-     * @param seedFactory - Produces the initial accumulator value per subscription.
-     * @param reducer - Combines the running accumulator with the next item.
-     * @returns A `Mono<A>` emitting the final reduced value.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2, 3)
-     *   .reduceWith(() => '', (acc, n) => acc + n)
-     *   .subscribe(v => console.log(v)); // '123'
-     * ```
-     */
-    reduceWith<A>(seedFactory: () => A, reducer: (acc: A, next: T) => A): Mono<A>;
-    /**
-     * Ignores all items from this `Flux` and emits a single `void` value on completion.
-     *
-     * Useful when you care only about the completion signal, not about the emitted items.
-     * If the source errors, the error is forwarded.
-     *
-     * @returns A `Mono<void>` that signals when this `Flux` completes.
-     */
-    then(): Mono<void>;
-    /**
-     * Ignores all items from this `Flux`, then subscribes to `other` after this source completes,
-     * draining `other` completely and returning a `Mono<void>`.
-     *
-     * If this source or `other` errors, the error is forwarded.
-     *
-     * @param other - A `Publisher` to subscribe to after this source completes.
-     * @returns A `Mono<void>` that completes once `other` completes.
-     */
-    thenEmpty(other: Publisher<unknown>): Mono<void>;
-    /**
-     * Re-subscribes to the source when the publisher returned by `fn` emits,
-     * enabling controlled retry with strategies like exponential back-off.
-     *
-     * `fn` receives a `Flux<Error>` — the stream of errors emitted by each failed attempt.
-     * Each emission from the returned publisher triggers a retry.
-     * When the returned publisher completes or errors, the retry loop stops.
-     *
-     * @param fn - Receives an error stream and returns a control publisher.
-     * @returns A `Flux<T>` with dynamic retry behaviour.
-     *
-     * @example
-     * ```typescript
-     * // Exponential back-off: wait 2^n × 100ms between retries, max 3 retries
-     * flux.retryWhen(errors =>
-     *   errors.zipWith(Flux.range(1, 3), (_, n) => n)
-     *         .flatMap(n => Mono.delay(n * 100))
-     * );
-     * ```
-     */
-    retryWhen(fn: (errors: Flux<Error>) => Publisher<unknown>): Flux<T>;
-    /**
-     * Re-subscribes to the source each time it completes normally, as controlled by
-     * the publisher returned by `fn` (**polling** semantics).
-     *
-     * `fn` receives a `Flux<void>` — one emission per completion. Each emission triggers
-     * a repeat. When the control publisher completes or errors, the loop stops.
-     *
-     * @param fn - Receives a completion-signal stream and returns a control publisher.
-     * @returns A `Flux<T>` that repeats under the control of `fn`.
-     *
-     * @example
-     * ```typescript
-     * // Poll every second, stop after 5 times
-     * fetchLatest()
-     *   .toFlux()
-     *   .repeatWhen(completes => completes.zipWith(Flux.range(1, 5), (_, n) => n)
-     *                                     .flatMap(() => Mono.delay(1000)));
-     * ```
-     */
-    repeatWhen(fn: (completes: Flux<void>) => Publisher<unknown>): Flux<T>;
-    /**
-     * Groups items by a key derived from `keyFn`, emitting a {@link GroupedFlux} per
-     * unique key. Each `GroupedFlux` is itself a `Flux<T>` exposing the group `key`.
-     *
-     * The source is consumed at full speed. Items are routed to the corresponding group's
-     * buffer and replayed to any subscriber of that group.
-     *
-     * @param keyFn - Extracts the group key from each item.
-     * @returns A `Flux<GroupedFlux<K, T>>` emitting one group per unique key.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2, 3, 4, 5)
-     *   .groupBy(n => n % 2 === 0 ? 'even' : 'odd')
-     *   .flatMap(group => group.collectList().map(items => ({ key: group.key, items })))
-     *   .subscribe(v => console.log(v));
-     * // { key: 'odd', items: [1, 3, 5] }
-     * // { key: 'even', items: [2, 4] }
-     * ```
-     */
-    groupBy<K>(keyFn: (value: T) => K): Flux<GroupedFlux<K, T>>;
-    /**
-     * Buffers items into arrays emitted when either `maxSize` items accumulate
-     * **or** `ms` milliseconds elapse since the last flush — whichever comes first.
-     *
-     * @param maxSize - Maximum items per batch.
-     * @param ms - Maximum time (ms) to wait before flushing a partial batch.
-     * @returns A `Flux<T[]>` of batches.
-     *
-     * @example
-     * ```typescript
-     * // Batch up to 10 items or flush every 500ms
-     * eventStream.bufferTimeout(10, 500).subscribe(batch => sendBatch(batch));
-     * ```
-     */
-    bufferTimeout(maxSize: number, ms: number): Flux<T[]>;
-    /**
-     * Samples this `Flux`, emitting the **most recent** item whenever `trigger` emits.
-     *
-     * If no item has arrived since the last sample, the trigger emission is ignored.
-     * Useful for rate-limiting with external signals (scroll, resize, `requestAnimationFrame`).
-     *
-     * @param trigger - Controls when to sample; its value is ignored.
-     * @returns A `Flux<T>` emitting the latest value at each trigger tick.
-     */
-    sample(trigger: Publisher<unknown>): Flux<T>;
-    /**
-     * For each item, subscribes to `triggerFn(item)` and waits for it to emit or complete
-     * before forwarding the item downstream (**delayUntil** semantics).
-     *
-     * Triggers are executed sequentially (concatMap semantics). The trigger's value
-     * is ignored — only its timing matters.
-     *
-     * @param triggerFn - Returns a publisher whose first signal releases the item.
-     * @returns A `Flux<T>` where each item is held until its trigger fires.
-     *
-     * @example
-     * ```typescript
-     * Flux.just(1, 2, 3)
-     *   .delayUntil(() => Mono.delay(100))
-     *   .subscribe(v => console.log(v)); // each item delayed 100ms
-     * ```
-     */
-    delayUntil(triggerFn: (value: T) => Publisher<unknown>): Flux<T>;
-    /**
-     * Recursively expands each item using `fn`, emitting both the original items and
-     * all items produced by the expansion (**breadth-first** order).
-     *
-     * Useful for **pagination**: call `fn` with the current page to fetch the next,
-     * until `fn` returns empty.
-     *
-     * @param fn - Receives an item; returns a publisher of zero or more new items to expand.
-     * @returns A `Flux<T>` of all original and expanded items.
-     *
-     * @example
-     * ```typescript
-     * // Fetch all pages recursively
-     * fetchPage(1)
-     *   .toFlux()
-     *   .expand(page => page.hasNext ? fetchPage(page.nextId).toFlux() : Flux.empty())
-     *   .subscribe(page => process(page));
-     * ```
-     */
-    expand(fn: (value: T) => Publisher<T>): Flux<T>;
-    /**
-     * Recursively expands each item using `fn`, emitting both the original items and
-     * all items produced by the expansion (**depth-first** order).
-     *
-     * Unlike {@link expand} (breadth-first), each item's children are emitted immediately
-     * after the item itself, before any sibling items are processed. This mirrors a
-     * recursive pre-order tree traversal.
-     *
-     * @param fn - Receives an item; returns a publisher of zero or more new items to expand.
-     * @returns A `Flux<T>` of all original and expanded items in depth-first order.
-     *
-     * @example
-     * ```typescript
-     * // Tree: 1 → [2, 3], 2 → [4, 5], others → empty
-     * Flux.just(1)
-     *   .expandDeep(n =>
-     *     n === 1 ? Flux.just(2, 3) :
-     *     n === 2 ? Flux.just(4, 5) :
-     *     Flux.empty()
-     *   )
-     *   .subscribe(v => console.log(v));
-     * // 1 2 4 5 3  (depth-first pre-order)
-     * ```
-     */
-    expandDeep(fn: (value: T) => Publisher<T>): Flux<T>;
-    /**
-     * Pairs each item with the time elapsed (in ms) since the **previous** item
-     * (or since subscription for the first item).
-     *
-     * @returns A `Flux<[number, T]>` where the first element is elapsed milliseconds.
-     *
-     * @example
-     * ```typescript
-     * Flux.interval(100).take(3).elapsed().subscribe(([ms, n]) => console.log(ms, n));
-     * // ~100 0   ~100 1   ~100 2
-     * ```
-     */
-    elapsed(): Flux<[number, T]>;
-    /**
-     * Attaches a `Date.now()` timestamp (in ms since epoch) to each item.
-     *
-     * @returns A `Flux<[number, T]>` where the first element is the Unix timestamp in ms.
-     */
-    timestamp(): Flux<[number, T]>;
-    /**
-     * Wraps each signal (next, error, complete) into a {@link Signal} data object,
-     * emitting them all as `onNext` items on a `Flux<Signal<T>>`.
-     *
-     * After materializing, the resulting `Flux` always completes normally (errors become
-     * `Signal.error` items rather than `onError` signals).
-     * Use {@link dematerialize} to convert back.
-     *
-     * @returns A `Flux<Signal<T>>` where every event is represented as a data item.
-     */
-    materialize(): Flux<Signal<T>>;
-    /**
-     * Unwraps a `Flux<Signal<R>>` back into a regular `Flux<R>`, restoring
-     * `error` and `complete` signals from their materialized form.
-     *
-     * This is the inverse of {@link materialize}.
-     *
-     * @returns A `Flux<R>` with signals restored from the `Signal` wrappers.
-     */
-    dematerialize<R>(this: Flux<Signal<R>>): Flux<R>;
-    /**
-     * Buffers all upstream items regardless of downstream demand, delivering them
-     * when demand becomes available.
-     *
-     * If `maxSize` is exceeded, an overflow error is signalled downstream.
-     *
-     * @param maxSize - Maximum buffer capacity (default: unbounded).
-     * @returns A `Flux<T>` with explicit backpressure buffering.
-     */
-    onBackpressureBuffer(maxSize?: number): Flux<T>;
-    /**
-     * Drops upstream items that arrive when downstream has no outstanding demand.
-     *
-     * An optional `onDrop` callback is invoked for each dropped item.
-     *
-     * @param onDrop - Optional callback called with each dropped item.
-     * @returns A `Flux<T>` with drop backpressure strategy.
-     */
-    onBackpressureDrop(onDrop?: (value: T) => void): Flux<T>;
-    /**
-     * Keeps only the **latest** upstream item when downstream has no demand;
-     * older buffered items are overwritten as new ones arrive.
-     *
-     * @returns A `Flux<T>` with latest-value backpressure strategy.
-     */
-    onBackpressureLatest(): Flux<T>;
-    /**
-     * Requests items from upstream in batches of `n`, replenishing when 75% of
-     * the batch has been consumed (**prefetch** / **limitRate** semantics).
-     *
-     * Prevents requesting all items at once from expensive sources.
-     *
-     * @param n - Prefetch batch size.
-     * @returns A `Flux<T>` with controlled upstream demand.
-     */
-    limitRate(n: number): Flux<T>;
-    /**
-     * Filters items by runtime type, passing only items that are instances of `constructor`.
-     *
-     * @typeParam R - The target subtype.
-     * @param constructor - The class/constructor to filter by.
-     * @returns A `Flux<R>` containing only items that pass `instanceof`.
-     *
-     * @example
-     * ```typescript
-     * class Cat { meow() {} }
-     * class Dog { bark() {} }
-     * Flux.just(new Cat(), new Dog(), new Cat())
-     *   .ofType(Cat)
-     *   .subscribe(cat => cat.meow());
-     * ```
-     */
-    ofType<R extends T>(constructor: new (...args: unknown[]) => R): Flux<R>;
-    /**
-     * Applies a reusable operator function `fn` to this `Flux`, deferred per subscription.
-     *
-     * `fn` receives this `Flux<T>` (as a `Publisher<T>`) and returns a new `Publisher<R>`.
-     * The transformation is re-evaluated on each `subscribe()` call (deferred assembly).
-     *
-     * @param fn - Operator function to apply.
-     * @returns A `Flux<R>` produced by `fn`.
-     *
-     * @example
-     * ```typescript
-     * const retryThrice = <T>(source: Publisher<T>) => Flux.from(source).retry(3);
-     * Flux.just(1, 2).transformDeferred(retryThrice).subscribe(v => console.log(v));
-     * ```
-     */
-    transformDeferred<R>(fn: (flux: Publisher<T>) => Publisher<R>): Flux<R>;
-}
-/**
- * A `Flux<T>` tagged with a group `key`.
- *
- * Produced by {@link Flux#groupBy} — subscribe to it exactly like any `Flux<T>`;
- * the extra `key` property identifies which group this stream belongs to.
- *
- * Implemented as a plain type intersection rather than a subclass: the runtime
- * object is an ordinary `Flux<T>` with a `key` property attached via
- * `Object.assign`, so no extra prototype chain is required.
- *
- * @typeParam K - The type of the group key.
- * @typeParam T - The type of items in the group.
- */
-type GroupedFlux<K, T> = Flux<T> & {
-    readonly key: K;
-};
-
-/**
- * A cold publisher of 0 or 1 items with full backpressure support.
- *
- * A `Mono` emits at most one value followed by `onComplete`, or signals `onError`.
- * Items flow only when the downstream {@link Subscription} issues `request(n)`.
- * The convenience `subscribe(onNext, onError, onComplete)` overloads automatically
- * request `1` so the value starts flowing without extra ceremony.
- *
- * Each `subscribe()` call creates an **independent** run of the pipeline ("cold" semantics).
- *
- * @typeParam T - The type of the single item emitted by this Mono.
- *
- * @example
- * ```typescript
- * Mono.just(42)
- *   .map(n => n * 2)
- *   .subscribe(v => console.log(v));
- * // 84
- * ```
- */
-declare class Mono<T> extends AbstractPipePublisher<T, Mono<T>> implements PipePublisher<T> {
-    protected constructor(source: Publisher<T>);
-    protected defaultDemand(): number;
-    protected wrapSource(source: Publisher<T>): Mono<T>;
-    /**
-     * Creates a `Mono` from a generator function that pushes a value imperatively.
-     *
-     * The generator receives a {@link Sink} and should call exactly one of:
-     * - `sink.next(value)` — emits the value and completes.
-     * - `sink.error(err)` — terminates with an error.
-     * - `sink.complete()` — completes without emitting a value (empty `Mono`).
-     *
-     * Delivery is deferred until the downstream subscriber issues `request(n)`.
-     * Rule 1.3 is respected — `onSubscribe` is delivered before the generator runs.
-     *
-     * @param generator - Function that drives the `Mono` via the provided `Sink<T>`.
-     * @returns A cold `Mono<T>`.
-     *
-     * @example
-     * ```typescript
-     * Mono.generate<number>(sink => sink.next(42)).subscribe(v => console.log(v)); // 42
-     * ```
-     */
-    static generate<T>(generator: (sink: Sink<T>) => void): Mono<T>;
-    /**
-     * Wraps an existing {@link Publisher} as a `Mono`.
-     *
-     * @param publisher - Any `Publisher<T>` to adapt.
-     * @returns A `Mono<T>` backed by the given publisher.
-     */
-    static from<T>(publisher: Publisher<T>): Mono<T>;
-    /**
-     * Creates a `Mono` that emits `value` then completes.
-     *
-     * @param value - The single item to emit.
-     * @returns A cold `Mono<T>`.
-     *
-     * @example
-     * ```typescript
-     * Mono.just(42).subscribe(v => console.log(v)); // 42
-     * ```
-     */
-    static just<T>(value: T): Mono<T>;
-    /**
-     * Creates a `Mono` that emits `value` if it is non-null and non-undefined,
-     * or completes empty if `value` is `null` or `undefined`.
-     *
-     * @param value - The value to emit, or `null`/`undefined` for an empty Mono.
-     * @returns A `Mono<T>` that emits the value or completes immediately.
-     */
-    static justOrEmpty<T>(value: T | null | undefined): Mono<T>;
-    /**
-     * Creates a `Mono` that completes immediately without emitting any value.
-     *
-     * @returns An empty, completed `Mono<T>`.
-     */
-    static empty<T = never>(): Mono<T>;
-    /**
-     * Creates a `Mono` that signals `onError` immediately upon subscription.
-     *
-     * @param error - The error to signal (wrapped in an `Error` if not already one).
-     * @returns An errored `Mono<T>`.
-     */
-    static error<T = never>(error: unknown): Mono<T>;
-    /**
-     * Creates a `Mono` that adapts a `Promise<T>`.
-     *
-     * The resolved value is emitted as the single item; a rejected promise signals `onError`.
-     *
-     * @param promise - The promise to adapt.
-     * @returns A `Mono<T>` backed by the promise.
-     *
-     * @example
-     * ```typescript
-     * Mono.fromPromise(fetch('/api/data').then(r => r.json()))
-     *   .subscribe(data => console.log(data));
-     * ```
-     */
-    static fromPromise<T>(promise: Promise<T>): Mono<T>;
-    /**
-     * Lazily creates a new `Mono` per subscription by calling `factory`.
-     *
-     * Useful when the source depends on mutable state that should be captured
-     * at subscribe time rather than at assembly time.
-     *
-     * @param factory - Called once per subscription to produce the actual `Mono<T>`.
-     * @returns A lazy `Mono<T>`.
-     */
-    static defer<T>(factory: () => Mono<T>): Mono<T>;
-    /**
-     * Alias for {@link Mono.generate} — imperative push interface.
-     *
-     * The generator receives a {@link Sink} and should call exactly one of:
-     * `sink.next(value)`, `sink.error(err)`, or `sink.complete()`.
-     *
-     * @param generator - Function that drives the `Mono` via the provided `Sink<T>`.
-     * @returns A cold `Mono<T>`.
-     */
-    static create<T>(generator: (sink: Sink<T>) => void): Mono<T>;
-    /**
-     * Creates a `Mono<number>` that emits `0` after `ms` milliseconds then completes.
-     *
-     * Useful for introducing timed delays in reactive pipelines.
-     *
-     * @param ms - The delay in milliseconds.
-     * @returns A `Mono<number>` that emits `0` after the delay.
-     *
-     * @example
-     * ```typescript
-     * Mono.delay(500).flatMap(() => Mono.just('hello')).subscribe(v => console.log(v));
-     * ```
-     */
-    static delay(ms: number): Mono<number>;
-    /**
-     * Creates a `Mono<T>` from a synchronous, potentially-throwing factory function.
-     *
-     * The factory is called **lazily** at subscription time (not at assembly time).
-     * If the factory throws, the exception is forwarded as `onError`.
-     *
-     * @param fn - Synchronous factory invoked once per subscription.
-     * @returns A cold `Mono<T>`.
-     *
-     * @example
-     * ```typescript
-     * Mono.fromCallable(() => JSON.parse(rawJson)).subscribe(v => console.log(v));
-     * ```
-     */
-    static fromCallable<T>(fn: () => T): Mono<T>;
-    /**
-     * Races multiple `Mono`s — emits the first value to arrive, cancelling the rest.
-     *
-     * If a source completes without emitting, it is excluded from the race.
-     * If **all** sources complete empty, the resulting `Mono` also completes empty.
-     * If any source errors before another source emits, the error is propagated.
-     *
-     * @param sources - One or more `Mono<T>` sources to race.
-     * @returns A `Mono<T>` that emits the first available value.
-     *
-     * @example
-     * ```typescript
-     * Mono.firstWithValue(slow, fast).subscribe(v => console.log(v)); // fast's value
-     * ```
-     */
-    static firstWithValue<T>(...sources: Mono<T>[]): Mono<T>;
-    /**
-     * Returns a `Mono<void>` that completes when **all** given publishers complete.
-     *
-     * Emitted values from the sources are ignored. If any source signals `onError`,
-     * the error is propagated immediately and all other sources are cancelled.
-     * If no sources are provided, completes immediately.
-     *
-     * @param sources - Zero or more publishers to wait on.
-     * @returns A `Mono<void>` that completes once every source has completed.
-     *
-     * @example
-     * ```typescript
-     * Mono.when(Mono.delay(100), Mono.delay(200))
-     *   .subscribe(undefined, undefined, () => console.log('all done'));
-     * ```
-     */
-    static when(...sources: Publisher<unknown>[]): Mono<void>;
-    /**
-     * Transforms the emitted value using `fn`, producing a `Mono<R>`.
-     *
-     * If `fn` throws, the exception is forwarded to `onError` and the stream terminates.
-     *
-     * @param fn - Mapping function applied to the emitted value.
-     * @returns A new `Mono<R>`.
-     *
-     * @example
-     * ```typescript
-     * Mono.just(42).map(n => n.toString()).subscribe(v => console.log(v)); // '42'
-     * ```
-     */
-    map<R>(fn: (value: T) => R): Mono<R>;
-    /**
-     * Transforms the emitted value with `fn`, completing empty if the result is `null` or `undefined`.
-     *
-     * @param fn - Mapping function; returning `null` or `undefined` produces an empty `Mono`.
-     * @returns A `Mono<NonNullable<R>>` that completes empty when the mapping returns null.
-     */
-    mapNotNull<R>(fn: (value: T) => R | null | undefined): Mono<NonNullable<R>>;
-    /**
-     * Maps the emitted value to an inner `Mono<R>` and flattens the result.
-     *
-     * When the source emits a value, `fn` is called and the resulting inner `Mono` is
-     * subscribed to. The inner `Mono`'s value (or completion/error) is forwarded downstream.
-     *
-     * @param fn - Maps the emitted value to a `Mono<R>` or any `Publisher<R>`.
-     * @returns A `Mono<R>` containing the result of the inner publisher.
-     */
-    flatMap<R>(fn: (value: T) => Mono<R>): Mono<R>;
-    flatMap<R>(fn: (value: T) => Publisher<R>): Mono<R>;
-    /**
-     * Passes the emitted value downstream only if `predicate` returns `true`;
-     * otherwise completes the `Mono` without emitting.
-     *
-     * @param predicate - Synchronous test applied to the emitted value.
-     * @returns A `Mono<T>` that completes empty when the predicate fails.
-     */
-    filter(predicate: (value: T) => boolean): Mono<T>;
-    /**
-     * Asynchronous filter: subscribes to `predicate(value)` and forwards the value
-     * downstream only if the predicate publisher emits `true`; otherwise completes empty.
-     *
-     * @param predicate - Returns a `Publisher<boolean>` for the emitted value.
-     * @returns A `Mono<T>` that completes empty when the predicate is not satisfied.
-     */
-    filterWhen(predicate: (value: T) => Publisher<boolean>): Mono<T>;
-    /**
-     * Unsafe type cast — changes the declared element type to `R` without any
-     * runtime conversion. Use only when you are certain the actual runtime type is compatible.
-     *
-     * @typeParam R - The target element type.
-     * @returns This `Mono` re-typed as `Mono<R>`.
-     */
-    cast<R>(): Mono<R>;
-    /**
-     * Executes a side-effect function after the stream ends for **any** reason —
-     * normal completion or error. Unlike {@link Flux#doFinally}, this does not fire on
-     * cancellation (a `Mono` cancel is semantically identical to an unneeded result).
-     *
-     * Any exception thrown by `fn` is silently swallowed.
-     *
-     * @param fn - Side-effect to run after any terminal event.
-     * @returns A `Mono<T>` with the side effect attached.
-     */
-    doFinally(fn: () => void): Mono<T>;
-    /**
-     * Low-level escape hatch for bridging imperative push-based sources into a `Mono<R>`.
-     *
-     * The `producer` receives three callbacks and must call them to drive the stream.
-     * `onRequest` and `onUnsubscribe` let the caller respond to downstream demand and
-     * cancellation respectively.
-     *
-     * @param producer - Callback that receives `(onNext, onError, onComplete)` and drives the stream.
-     * @param onRequest - Called when the downstream subscriber requests `n` more items.
-     * @param onUnsubscribe - Called when the downstream subscriber cancels.
-     * @returns A `Mono<R>` backed by the imperative producer.
-     */
-    pipe<R>(producer: (onNext: (value: R) => void, onError: (error: Error) => void, onComplete: () => void) => void, onRequest: (request: number) => void, onUnsubscribe: () => void): Mono<R>;
-    /**
-     * Maps the emitted value to a multi-item publisher and returns the items as a `Flux<R>`.
-     *
-     * The inner publisher is subscribed to once the source emits its single value.
-     * All items from the inner publisher are forwarded downstream. If the source is empty,
-     * the resulting `Flux` also completes empty.
-     *
-     * @param mapper - Maps the emitted value to a `Flux<R>`, `Mono<R>`, or any `Publisher<R>`.
-     * @returns A `Flux<R>` containing all items from the inner publisher.
-     *
-     * @example
-     * ```typescript
-     * Mono.just(3)
-     *   .flatMapMany(n => Flux.range(1, n))
-     *   .subscribe(v => console.log(v)); // 1  2  3
-     * ```
-     */
-    flatMapMany<R>(mapper: (value: T) => Flux<R>): Flux<R>;
-    flatMapMany<R>(mapper: (value: T) => Mono<R>): Flux<R>;
-    flatMapMany<R>(mapper: (value: T) => Publisher<R>): Flux<R>;
-    /**
-     * Subscribes to this `Mono` and `other` concurrently and combines their values
-     * into a `[T, R]` tuple once both emit.
-     *
-     * If either `Mono` completes empty, the resulting `Mono` also completes empty.
-     * If either errors, the error is forwarded and the other is cancelled.
-     *
-     * @param other - The second `Mono` to zip with.
-     * @returns A `Mono<[T, R]>` emitting the combined tuple.
-     *
-     * @example
-     * ```typescript
-     * Mono.just(1).zipWith(Mono.just('a')).subscribe(([n, s]) => console.log(n, s)); // 1 a
-     * ```
-     */
-    zipWith<R>(other: Mono<R>): Mono<[T, R]>;
-    /**
-     * Emits the source value and uses `fn` to derive a second `Mono`, combining both into a tuple.
-     *
-     * The source value is passed to `fn` to produce the second `Mono`. Both values are then
-     * combined into a `[T, R]` tuple. If either `Mono` is empty or errors, those signals
-     * propagate to the subscriber.
-     *
-     * @param fn - Called with the emitted value to produce the second `Mono<R>`.
-     * @returns A `Mono<[T, R]>` emitting both values as a tuple.
-     *
-     * @example
-     * ```typescript
-     * Mono.just(42).zipWhen(n => Mono.just(n.toString())).subscribe(([n, s]) => console.log(n, s));
-     * // 42 '42'
-     * ```
-     */
-    zipWhen<R>(fn: (value: T) => Mono<R>): Mono<[T, R]>;
-    /**
-     * Emits `true` if this `Mono` emits a value, `false` if it completes empty.
-     *
-     * @returns A `Mono<boolean>`.
-     */
-    hasElement(): Mono<boolean>;
-    /**
-     * Side effect executed when the `Mono` emits its value.
-     *
-     * Does **not** affect the emitted value or stream lifecycle.
-     * Exceptions thrown by `fn` are forwarded as `onError`.
-     *
-     * @param fn - Called with the emitted value.
-     * @returns A `Mono<T>` with the side effect attached.
-     *
-     * @example
-     * ```typescript
-     * Mono.just(42).doOnSuccess(v => console.log('got', v)).subscribe();
-     * ```
-     */
-    doOnSuccess(fn: (value: T) => void): Mono<T>;
-    /**
-     * Converts a terminal error into a normal `onComplete` signal.
-     *
-     * If a `predicate` is supplied, only errors for which the predicate returns `true`
-     * are swallowed; others are re-propagated as-is.
-     *
-     * @param predicate - Optional filter; when absent all errors are converted.
-     * @returns A `Mono<T>` that completes rather than errors (when predicate matches).
-     *
-     * @example
-     * ```typescript
-     * Mono.error(new Error('oops')).onErrorComplete().subscribe(undefined, undefined, () => console.log('done'));
-     * ```
-     */
-    onErrorComplete(predicate?: (e: Error) => boolean): Mono<T>;
-    /**
-     * Ignores any value emitted by this `Mono` and, upon normal completion,
-     * emits `value` instead.
-     *
-     * Errors from the source are propagated unchanged.
-     *
-     * @param value - The value to emit after this `Mono` completes.
-     * @returns A `Mono<R>` that emits `value` on source completion.
-     *
-     * @example
-     * ```typescript
-     * Mono.just('ignored').thenReturn(42).subscribe(v => console.log(v)); // 42
-     * ```
-     */
-    thenReturn<R>(value: R): Mono<R>;
-    /**
-     * Ignores the value emitted by this `Mono` and, upon completion, subscribes to `other`
-     * and forwards its result downstream.
-     *
-     * If `other` is omitted, returns a `Mono<void>` that completes when this `Mono` completes.
-     * Errors from this `Mono` are propagated without subscribing to `other`.
-     *
-     * @param other - Optional `Mono<V>` to subscribe to after this `Mono` completes.
-     * @returns `Mono<void>` when called with no argument; `Mono<V>` when `other` is provided.
-     *
-     * @example
-     * ```typescript
-     * // Sequencing: run A, then run B and return B's value
-     * Mono.just('ignored').then(Mono.just(42)).subscribe(v => console.log(v)); // 42
-     *
-     * // Completion signal only
-     * Mono.just('ignored').then().subscribe(undefined, undefined, () => console.log('done'));
-     * ```
-     */
-    then(): Mono<void>;
-    then<V>(other: Mono<V>): Mono<V>;
-    /**
-     * Ignores the value (or absence of a value) emitted by this `Mono` and, once
-     * the source completes, subscribes to the provided `Publisher<V>` and forwards
-     * all of its items and terminal signal downstream as a `Flux<V>`.
-     *
-     * If the source signals an error the error is forwarded immediately and `other`
-     * is never subscribed.
-     *
-     * This mirrors `Mono#thenMany` from Project Reactor.
-     *
-     * @param other - The publisher whose items should be delivered after this Mono completes.
-     * @returns A `Flux<V>` that forwards all items from `other`.
-     *
-     * @example
-     * ```typescript
-     * Mono.just('init')
-     *   .thenMany(Flux.just(1, 2, 3))
-     *   .subscribe(v => console.log(v));
-     * // 1  2  3
-     * ```
-     */
-    thenMany<V>(other: Publisher<V>): Flux<V>;
-    /**
-     * Delays delivery of the emitted value by `ms` milliseconds.
-     *
-     * The delay is introduced **after** the source emits; completion and errors
-     * are forwarded without delay.
-     *
-     * @param ms - Delay in milliseconds.
-     * @returns A `Mono<T>` whose value arrives `ms` milliseconds later.
-     *
-     * @example
-     * ```typescript
-     * Mono.just('hello').delayElement(200).subscribe(v => console.log(v));
-     * ```
-     */
-    delayElement(ms: number): Mono<T>;
-    /**
-     * Holds the emitted value until a trigger publisher (returned by `triggerFn`) emits
-     * or completes, then forwards the value downstream.
-     *
-     * If the trigger errors, the error is propagated and the value is discarded.
-     * If the source is empty, completes immediately without invoking `triggerFn`.
-     *
-     * @param triggerFn - Receives the emitted value and returns a trigger `Publisher`.
-     * @returns A `Mono<T>` that emits after the trigger fires.
-     *
-     * @example
-     * ```typescript
-     * Mono.just(42).delayUntil(() => Mono.delay(300)).subscribe(v => console.log(v));
-     * ```
-     */
-    delayUntil(triggerFn: (value: T) => Publisher<unknown>): Mono<T>;
-    /**
-     * Falls back to `other` if this `Mono` completes without emitting a value (empty).
-     *
-     * If this `Mono` emits a value or errors, `other` is never subscribed to.
-     *
-     * @param other - The fallback `Mono<T>` to subscribe to when the source is empty.
-     * @returns A `Mono<T>` that emits from `other` when the source is empty.
-     *
-     * @example
-     * ```typescript
-     * Mono.empty<number>().or(Mono.just(99)).subscribe(v => console.log(v)); // 99
-     * ```
-     */
-    or(other: Mono<T>): Mono<T>;
-    /**
-     * Re-subscribes to this `Mono` on error, using a control publisher to decide
-     * whether and when to retry.
-     *
-     * Each time the source errors, the error is pushed to the control stream returned
-     * by `fn`. If that stream emits any item, the source is re-subscribed. If it
-     * completes or errors, that terminal signal is forwarded downstream.
-     *
-     * @param fn - Receives a `Flux<Error>` of upstream errors; returns a control publisher.
-     * @returns A `Mono<T>` that retries according to the control signal.
-     *
-     * @example
-     * ```typescript
-     * Mono.error(new Error('boom'))
-     *   .retryWhen(errors => errors.take(3))
-     *   .subscribe(undefined, e => console.error(e));
-     * ```
-     */
-    retryWhen(fn: (errors: Flux<Error>) => Publisher<unknown>): Mono<T>;
-    /**
-     * Alias for {@link Mono#toPromise} — returns a `Promise<T | null>` that resolves
-     * with the emitted value (or `null` if the `Mono` is empty).
-     *
-     * @returns A `Promise<T | null>`.
-     */
-    toFuture(): Promise<T | null>;
-    /**
-     * Subscribes to this `Mono` and returns a `Promise<T | null>`.
-     *
-     * The promise resolves with the emitted value, or with `null` if the `Mono` completes empty.
-     * The promise rejects if the `Mono` signals an error.
-     *
-     * @returns A `Promise<T | null>` that resolves when the `Mono` terminates.
-     */
-    toPromise(): Promise<T | null>;
-}
-
-/**
- * A scheduler that immediately executes tasks.
- * Implements the `Scheduler` interface to execute tasks without any delay.
- */
-declare class ImmediateScheduler implements Scheduler {
-    /**
-     * Schedules a task to be executed immediately.
-     * @param {Function} task - The task function to be executed.
-     */
-    schedule(task: () => void): void;
-}
-
-/**
- * A scheduler that executes tasks asynchronously using the microtask queue.
- * Implements the `Scheduler` interface and schedules tasks using `Promise.resolve().then(...)`.
- */
-declare class MicroScheduler implements Scheduler {
-    /**
-     * Schedules a task to be executed asynchronously as a microtask.
-     * Uses `Promise.resolve().then(task)` to place the task in the microtask queue.
-     * @param {Function} task - The task function to be executed.
-     */
-    schedule(task: () => void): void;
-}
-
-/**
- * A scheduler that executes tasks asynchronously using the macro task queue.
- * Implements the `Scheduler` interface and schedules tasks using `setTimeout` with a delay of `0`.
- */
-declare class MacroScheduler implements Scheduler {
-    /**
-     * Schedules a task to be executed asynchronously.
-     * Uses `setTimeout` with a delay of `0` to place the task in the macro task queue.
-     * @param {Function} task - The task function to be executed.
-     */
-    schedule(task: () => void): void;
-}
-
-/**
- * A scheduler that executes tasks after a specified delay.
- * Implements the `CancellableScheduler` interface, allowing scheduled tasks to be canceled.
- */
-declare class DelayScheduler implements CancellableScheduler {
-    private readonly delay;
-    /**
-     * Creates a new DelayScheduler.
-     * @param {number} delay - The delay duration in milliseconds.
-     */
-    constructor(delay: number);
-    /**
-     * Schedules a task to be executed after the specified delay.
-     * Returns an object with a cancel method to clear the timeout.
-     * @param {Function} task - The task function to be executed.
-     * @returns {Object} An object with a `cancel` method to stop the execution.
-     */
-    schedule(task: () => void): {
-        cancel: () => void;
-    };
-}
-
-/**
- * A scheduler that executes tasks multiple times with a specified interval.
- * Implements the `CancellableScheduler` interface, allowing scheduled tasks to be canceled.
- */
-declare class IntervalScheduler implements CancellableScheduler {
-    private readonly interval;
-    /**
-     * Creates a new IntervalScheduler.
-     * @param {number} delay - The interval duration in milliseconds.
-     */
-    constructor(delay: number);
-    /**
-     * Schedules a task to be executed multiple times with a specified interval.
-     * Returns an object with a cancel method to clear the timeout.
-     * @param {Function} task - The task function to be executed.
-     * @returns {Object} An object with a `cancel` method to stop the execution.
-     */
-    schedule(task: () => void): {
-        cancel: () => void;
-    };
-}
-
-/**
- * A collection of commonly used schedulers for task execution.
- * Provides methods to create instances of various scheduler types.
- */
-declare const Schedulers: {
-    /**
-     * Creates an instance of `ImmediateScheduler`.
-     * Executes tasks immediately without any delay.
-     * @returns {ImmediateScheduler} An instance of ImmediateScheduler.
-     */
-    immediate: () => ImmediateScheduler;
-    /**
-     * Creates an instance of `MicroScheduler`.
-     * Executes tasks asynchronously using the microtask queue.
-     * @returns {MicroScheduler} An instance of MicroScheduler.
-     */
-    micro: () => MicroScheduler;
-    /**
-     * Creates an instance of `MacroScheduler`.
-     * Executes tasks asynchronously using the macro task queue (via `setTimeout`).
-     * @returns {MacroScheduler} An instance of MacroScheduler.
-     */
-    macro: () => MacroScheduler;
-    /**
-     * Creates an instance of `DelayScheduler` with a specified delay.
-     * Executes tasks after a given delay using `setTimeout`.
-     * @param {number} ms - The delay in milliseconds before executing the task.
-     * @returns {DelayScheduler} An instance of DelayScheduler.
-     */
-    delay: (ms: number) => DelayScheduler;
-    /**
-     * Creates an instance of `IntervalScheduler` with a specified interval.
-     * Executes tasks multiple times with a given interval using `setInterval`.
-     * @param {number} ms - The interval in milliseconds between task executing.
-     * @returns {IntervalScheduler} An instance of IntervalScheduler.
-     */
-    interval: (ms: number) => IntervalScheduler;
-};
-
-/**
- * A {@link Sink} that is also a {@link Publisher}, with a convenience `asFlux()` accessor.
- * Callers can push values via the `Sink` interface, subscribe via the `Publisher` interface,
- * or obtain a full-featured {@link Flux} view via `asFlux()`.
- */
-type SinkPublisher<T> = Sink<T> & Publisher<T> & {
-    asFlux(): Flux<T>;
-};
-
-/**
- * Factory namespace for creating hot or replayable sink/publisher pairs.
- *
- * Each factory returns a {@link SinkPublisher} that implements both {@link Sink} (for pushing values)
- * and {@link Publisher} (for subscribing).
- *
- * @example
- * ```typescript
- * const sink = Sinks.many().multicast().directBestEffort<number>();
- * const flux = Flux.from(sink);
- * flux.subscribe(v => console.log(v));
- * sink.next(1);
- * sink.next(2);
- * sink.complete();
- * ```
- */
-declare const Sinks: {
-    /**
-     * A sink that immediately completes any subscriber without emitting values.
-     * Equivalent to `Flux.empty()` but hot/shared.
-     */
-    empty: <T>() => SinkPublisher<T>;
-    /**
-     * A sink for exactly one value. Replays that value (and subsequent completion) to all subscribers.
-     * Use for single-result async operations.
-     */
-    one: <T>() => SinkPublisher<T>;
-    /** Creates a multi-subscriber sink factory. */
-    many: () => {
-        /** Creates multicast (fan-out) sinks that deliver to all current subscribers. */
-        multicast: () => {
-            /**
-             * Delivers each item to all current subscribers simultaneously.
-             * If any subscriber cannot accept the item (due to backpressure), **none** of them receive it.
-             */
-            directAllOrNothing: <T>() => SinkPublisher<T>;
-            /**
-             * Delivers each item to all current subscribers on a best-effort basis.
-             * Subscribers that are not ready (backpressure) are skipped for that item.
-             */
-            directBestEffort: <T>() => SinkPublisher<T>;
-            /**
-             * Buffers items and delivers them to all subscribers respecting backpressure.
-             *
-             * @param bufferSize - Maximum number of items to buffer (default: `256`).
-             * @param autoCancel - If `true`, cancels the sink when all subscribers unsubscribe (default: `true`).
-             */
-            onBackpressureBuffer: <T>(bufferSize?: number, autoCancel?: boolean) => SinkPublisher<T>;
-        };
-        /** Creates unicast (single-subscriber) sinks. */
-        unicast: () => {
-            /**
-             * Unicast sink that buffers items until the single subscriber requests them.
-             * A second `subscribe()` call throws.
-             */
-            onBackpressureBuffer: <T>() => SinkPublisher<T>;
-            /**
-             * Unicast sink that errors if an item is pushed when the subscriber has no outstanding demand.
-             * A second `subscribe()` call throws.
-             */
-            onBackpressureError: <T>() => SinkPublisher<T>;
-        };
-        /** Creates replay sinks that buffer past items for late subscribers. */
-        replay: () => {
-            /**
-             * Replays **all** previously emitted items to each new subscriber.
-             * Items are accumulated indefinitely.
-             */
-            all: <T>() => SinkPublisher<T>;
-            /**
-             * Replays the most recent `limit` items to each new subscriber.
-             *
-             * @param limit - Maximum number of items to replay.
-             */
-            latest: <T>(limit: number) => SinkPublisher<T>;
-            /**
-             * Replays the most recent item (or `value` if nothing has been emitted yet) to each new subscriber.
-             *
-             * @param value - Default value replayed until the first `next()` call.
-             */
-            latestOrDefault: <T>(value: T) => SinkPublisher<T>;
-            /**
-             * Alias for {@link latest}. Replays the most recent `limit` items.
-             *
-             * @param limit - Maximum number of items to replay.
-             */
-            limit: <T>(limit: number) => SinkPublisher<T>;
-        };
-    };
-};
-
-export { type CancellableScheduler, type DOMEventTargetLike, type EventSourceLike, Flux, type FluxSink, type GroupedFlux, Mono, type NodeEventEmitterLike, type Publisher, type Scheduler, Schedulers, Signal, type Sink, type SinkPublisher, Sinks, type Subscriber, type Subscription, type WebSocketLike };
+ * @packageDocumentation
+ * Public package entrypoint.
+ *
+ * Only the stable consumer-facing Reactor surface is re-exported here. Internal
+ * helpers, implementation classes, errors, hooks and sink detail types are kept
+ * out of the package root on purpose.
+ */
+export type { Disposable } from "./core/types.js";
+export { Context } from "./context/context.js";
+export type { Publisher } from "./publisher/publisher.js";
+export type { Subscriber } from "./subscription/subscriber.js";
+export type { Subscription } from "./subscription/subscription.js";
+export { Flux } from "./publisher/flux-entrypoint.js";
+export { Mono } from "./publisher/mono-entrypoint.js";
+export { Sinks } from "./sinks/index.js";
+export { Schedulers } from "./schedulers/index.js";
+//# sourceMappingURL=index.d.ts.map