Namespace RxSharp

AsyncBridge: Bridges an Observable<T> to a Task<T>. Mirrors rxjs's firstValueFrom/lastValueFrom.

EmptyErrorException: Thrown by operators such as First when a source completes without emitting a value and no default was supplied. Mirrors rxjs's EmptyError.

GroupedObservable<TKey, T>: Concrete IGroupedObservable<TKey, T> used by GroupBy. Backed by a Subject<T> so it multicasts to every subscriber (matching rxjs's own GroupedObservable, which is itself a thin wrapper around a per-group Subject).

NotFoundErrorException: Thrown by Single when the source emits one or more values but none of them satisfy the supplied predicate. Mirrors rxjs's NotFoundError.

Notification: Factory helpers for Notification<T>. A non-generic sibling avoids CA1000 (static members on generic types).

Observable: Creation functions for Observable<T>. Mirrors rxjs's observable/ creation functions.

Observable<T>: A push-based sequence of values. Mirrors rxjs's Observable.

OperatorHelper: The building block every operator is written against. Mirrors rxjs's operate() helper.

RxConfig: Global, mutable configuration hooks. Mirrors rxjs's config module.

SequenceErrorException: Thrown by Single when more than one value (or more than one predicate match) is seen from the source. Mirrors rxjs's SequenceError.

SingleAssignmentDisposable: An IDisposable whose target is assigned after construction. Disposing before the target is assigned disposes that target as soon as it is set. Needed by operators (e.g. Take) that must be able to unsubscribe from a source before that source's own synchronous Subscribe call has returned — e.g. when the first emitted value already satisfies the operator.

Subscriber: Factory helpers for Subscriber<T>. A non-generic sibling avoids CA1000 (static members on generic types).

Subscriber<T>: Wraps an IObserver<T> with unsubscribe-aware, re-entrancy-guarded dispatch. Mirrors rxjs's Subscriber. Deliberately does not swallow exceptions thrown by the wrapped observer's callbacks: it is each operator's own responsibility to catch exceptions from user-supplied callbacks (projections, predicates, side effects) and forward them via OnError(Exception) — see RxSharp/Operators for the pattern. A generic catch-and-forward here would double up across nested operator chains and silently swallow errors instead of propagating them.

Subscription: A disposable that composes child teardown logic. Mirrors rxjs's Subscription.

TaskPoolScheduler: The default IScheduler, backed by Task.Delay(TimeSpan, CancellationToken).

UnsubscriptionException: Raised when one or more finalizers throw while a Subscription is being disposed. Mirrors rxjs's UnsubscriptionError.

Notification<T>: A materialized next/error/complete notification, represented as a plain, inert value instead of a live callback invocation. Produced by Materialize<T>(Observable<T>) (which turns a stream's notifications into Notification<T> values flowing through the stream, so e.g. an error becomes a value rather than terminating the stream) and consumed by Dematerialize<T>(Observable<Notification<T>>) (which converts them back).

TimeInterval<T>: A value tagged with the time elapsed since the previous emission (or since subscription, for the first emission). Produced by TimeInterval<T>(Observable<T>, IScheduler?).

Timestamp<T>: A value tagged with the wall-clock time it was received. Produced by Timestamp<T>(Observable<T>, IScheduler?).

Unit: Stands in for rxjs's never type parameter (e.g. streams that only ever error or complete).

IGroupedObservable<TKey, T>: An Observable<T>-shaped stream of values that all share a common Key. Mirrors rxjs's GroupedObservable, the type emitted by groupBy. Declared as an interface (rather than a subclass of Observable<T>, which is sealed) so it can still expose the same two-overload Subscribe shape callers already get from Observable<T>.

IScheduler: Schedules work after a delay. Mirrors rxjs's SchedulerLike. A minimal seam for now — see CLAUDE.md for the plan to grow this into a full scheduler hierarchy with a virtual-time implementation.

NotificationKind: Identifies which kind of notification a Notification<T> represents.

MonoTypeOperatorFunction<T>: An OperatorFunction<TSource, TResult> whose source and result element types are the same, e.g. Filter or Take.

OperatorFunction<TSource, TResult>: A function that transforms an Observable<T> into an Observable<T>, e.g. the shape of a bound operator ready to apply via Pipe<TSource, TResult>(Observable<TSource>, OperatorFunction<TSource, TResult>).