@fncts/observable 0.0.2 → 0.0.5

package/Observable/api.d.ts

@@ -1,71 +1,78 @@
 import { Observer } from "@fncts/observable/Observer";
 import { Unsubscribable, Subscription } from "@fncts/observable/Subscription";
-import { Observable } from "@fncts/observable/Observable";
 import { ReadableStreamLike } from "@fncts/observable/internal/util";
-import { IO } from "@fncts/io/IO";
-import { Lazy } from "@fncts/base/data/function";
-import { Cause } from "@fncts/base/data/Cause";
+import { IO } from "@fncts/io/IO/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
 import { SchedulerLike, SchedulerAction } from "@fncts/observable/Scheduler";
 import { Subscriber } from "@fncts/observable/Subscriber";
 import { FiberContext } from "@fncts/io/Fiber";
-import { RefinementWithIndex, Refinement } from "@fncts/base/data/Refinement";
-import { PredicateWithIndex, Predicate } from "@fncts/base/data/Predicate";
-import { Maybe } from "@fncts/base/data/Maybe";
-import { Either } from "@fncts/base/data/Either";
+import { RefinementWithIndex, Refinement } from "@fncts/base/data/Refinement/definition";
+import { PredicateWithIndex, Predicate } from "@fncts/base/data/Predicate/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Tag } from "@fncts/base/data/Tag/definition";
 import { Eq } from "@fncts/base/typeclass";
 import { Notification } from "@fncts/observable/Notification";
+import { Observable } from "@fncts/observable/Observable/definition";
 export interface Subscribable<E, A> {
     subscribe(observer: Partial<Observer<E, A>>): Unsubscribable;
 }
-export declare type ObservableInput<E = never, A = never> = Observable<E, A> | Subscribable<E, A> | AsyncIterable<A> | PromiseLike<A> | ArrayLike<A> | Iterable<A> | ReadableStreamLike<A> | IO<never, E, A>;
+export declare type ObservableInput<R = never, E = never, A = never> = Observable<R, E, A> | Subscribable<E, A> | AsyncIterable<A> | PromiseLike<A> | ArrayLike<A> | Iterable<A> | ReadableStreamLike<A> | IO<R, E, A>;
 /**
  * @tsplus static fncts.observable.ObservableOps halt
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function halt(defect: unknown): Observable<never, never>;
+export declare function halt(defect: unknown): Observable<never, never, never>;
 /**
  * @tsplus static fncts.observable.ObservableOps defer
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function defer<E, A>(observable: Lazy<ObservableInput<E, A>>): Observable<E, A>;
+export declare function defer<R, E, A>(observable: Lazy<ObservableInput<R, E, A>>): Observable<R, E, A>;
 /**
  * @tsplus static fncts.observable.ObservableOps empty
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function empty<A>(): Observable<never, A>;
+export declare function empty<A>(): Observable<never, never, A>;
+/**
+ * @tsplus static fncts.observable.ObservableOps environmentWithObservable
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function environmentWithObservable<R0, R, E, A>(f: (environment: Environment<R0>) => Observable<R, E, A>): Observable<R0 | R, E, A>;
 /**
  * @tsplus static fncts.observable.ObservableOps failCause
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function failCause<E>(cause: Cause<E>): Observable<E, never>;
+export declare function failCause<E>(cause: Cause<E>): Observable<never, E, never>;
 /**
  * @tsplus static fncts.observable.ObservableOps fail
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function fail<E>(e: E): Observable<E, never>;
+export declare function fail<E>(e: E): Observable<never, E, never>;
 /**
  * @tsplus static fncts.observable.ObservableOps from
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function from<E = never, A = never>(input: ObservableInput<E, A>): Observable<E, A>;
-export declare function fromArrayLike<A>(input: ArrayLike<A>): Observable<never, A>;
-export declare function fromAsyncIterable<A>(asyncIterable: AsyncIterable<A>): Observable<never, A>;
-export declare function fromIterable<A>(iterable: Iterable<A>): Observable<never, A>;
-export declare function fromPromise<A>(promise: PromiseLike<A>): Observable<never, A>;
-export declare function fromReadableStreamLike<A>(readableStream: ReadableStreamLike<A>): Observable<never, A>;
+export declare function from<R = never, E = never, A = never>(input: ObservableInput<R, E, A>): Observable<R, E, A>;
+export declare function fromArrayLike<A>(input: ArrayLike<A>): Observable<never, never, A>;
+export declare function fromAsyncIterable<A>(asyncIterable: AsyncIterable<A>): Observable<never, never, A>;
+export declare function fromIterable<A>(iterable: Iterable<A>): Observable<never, never, A>;
+export declare function fromPromise<A>(promise: PromiseLike<A>): Observable<never, never, A>;
+export declare function fromReadableStreamLike<A>(readableStream: ReadableStreamLike<A>): Observable<never, never, A>;
 /**
  * @tsplus static fncts.observable.ObservableOps fromSubscribable
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function fromSubscribable<E, A>(subscribable: Subscribable<E, A>): Observable<E, A>;
+export declare function fromSubscribable<E, A>(subscribable: Subscribable<E, A>): Observable<never, E, A>;
 export declare function fromInterop<A>(subscribable: {
     subscribe: (observer: {
         next: (value: A) => void;
         error: (err: unknown) => void;
         complete: () => void;
     }) => Unsubscribable;
-}): Observable<unknown, A>;
-declare function _if<E, A, E1, B>(condition: () => boolean, onTrue: ObservableInput<E, A>, onFalse: ObservableInput<E1, B>): Observable<E | E1, A | B>;
+}): Observable<never, unknown, A>;
+declare function _if<R, E, A, R1, E1, B>(condition: () => boolean, onTrue: ObservableInput<R, E, A>, onFalse: ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, A | B>;
 export { _if as if };
 export interface IterateOptions<S> {
     readonly initialState: S;
@@ -73,207 +80,223 @@ export interface IterateOptions<S> {
     readonly iterate: (state: S) => S;
     readonly scheduler?: SchedulerLike;
 }
-export declare function iterate<S>(options: IterateOptions<S>): Observable<never, S>;
+export declare function iterate<S>(options: IterateOptions<S>): Observable<never, never, S>;
 /**
  * @tsplus static fncts.obervable.ObservableOps interval
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function interval(period?: number, scheduler?: SchedulerLike): Observable<never, number>;
+export declare function interval(period?: number, scheduler?: SchedulerLike): Observable<never, never, number>;
 /**
  * @tsplus static fncts.obervable.ObservableOps merge
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function merge<O extends ReadonlyArray<ObservableInput<any, any>>>(...sources: O): Observable<Observable.ErrorOf<O[number]>, Observable.TypeOf<O[number]>>;
-export declare function merge<O extends ReadonlyArray<ObservableInput<any, any>>>(...sources: [...O, number?]): Observable<Observable.ErrorOf<O[number]>, Observable.TypeOf<O[number]>>;
+export declare function merge<O extends ReadonlyArray<ObservableInput<any, any>>>(...sources: O): Observable<Observable.EnvironmentOf<O[number]>, Observable.ErrorOf<O[number]>, Observable.TypeOf<O[number]>>;
+export declare function merge<O extends ReadonlyArray<ObservableInput<any, any>>>(...sources: [...O, number?]): Observable<Observable.EnvironmentOf<O[number]>, Observable.ErrorOf<O[number]>, Observable.TypeOf<O[number]>>;
 /**
  * @tsplus static fncts.observable.ObservableOps of
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function of<A>(...items: ReadonlyArray<A>): Observable<never, A>;
+export declare function of<A>(...items: ReadonlyArray<A>): Observable<never, never, A>;
 /**
  * @tsplus static fncts.observable.ObservableOps single
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function single<A>(a: A): Observable<never, A>;
+export declare function single<A>(a: A): Observable<never, never, A>;
 /**
  * @tsplus fluent fncts.observable.Observable scheduled
  * @tsplus static fncts.observable.ObservableOps scheduled
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function scheduled<E, A>(input: ObservableInput<E, A>, scheduler: SchedulerLike): Observable<E, A>;
-export declare function scheduleArray<A>(input: ArrayLike<A>, scheduler: SchedulerLike): Observable<never, A>;
-export declare function scheduleAsyncIterable<A>(input: AsyncIterable<A>, scheduler: SchedulerLike): Observable<never, A>;
-export declare function scheduleIterable<A>(input: Iterable<A>, scheduler: SchedulerLike): Observable<never, A>;
-export declare function scheduleObservable<E, A>(input: Observable<E, A>, scheduler: SchedulerLike): Observable<E, A>;
-export declare function schedulePromise<A>(input: PromiseLike<A>, scheduler: SchedulerLike): Observable<never, A>;
-export declare function scheduleReadableStreamLike<A>(input: ReadableStreamLike<A>, scheduler: SchedulerLike): Observable<never, A>;
+export declare function scheduled<R, E, A>(input: ObservableInput<R, E, A>, scheduler: SchedulerLike): Observable<R, E, A>;
+export declare function scheduleArray<A>(input: ArrayLike<A>, scheduler: SchedulerLike): Observable<never, never, A>;
+export declare function scheduleAsyncIterable<A>(input: AsyncIterable<A>, scheduler: SchedulerLike): Observable<never, never, A>;
+export declare function scheduleIterable<A>(input: Iterable<A>, scheduler: SchedulerLike): Observable<never, never, A>;
+export declare function scheduleObservable<R, E, A>(input: Observable<R, E, A>, scheduler: SchedulerLike): Observable<R, E, A>;
+export declare function schedulePromise<A>(input: PromiseLike<A>, scheduler: SchedulerLike): Observable<never, never, A>;
+export declare function scheduleReadableStreamLike<A>(input: ReadableStreamLike<A>, scheduler: SchedulerLike): Observable<never, never, A>;
 /**
  * @tsplus static fncts.observable.ObservableOps timer
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function timer(time: number | Date, interval?: number, scheduler?: SchedulerLike): Observable<never, number>;
-export declare function timer(time: number | Date, scheduler?: SchedulerLike): Observable<never, number>;
+export declare function timer(time: number | Date, interval?: number, scheduler?: SchedulerLike): Observable<never, never, number>;
+export declare function timer(time: number | Date, scheduler?: SchedulerLike): Observable<never, never, number>;
 /**
  * @tsplus static fncts.observable.ObservableOps zip
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function makeZip<O extends ReadonlyArray<ObservableInput<any, any>>>(...sources: O): Observable<Observable.ErrorOf<O[number]>, {
+export declare function makeZip<O extends ReadonlyArray<ObservableInput<any, any>>>(...sources: O): Observable<Observable.EnvironmentOf<O[number]>, Observable.ErrorOf<O[number]>, {
     [K in keyof O]: Observable.TypeOf<O[K]>;
 }>;
 /**
  * @tsplus static fncts.observable.ObservableOps fromIO
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function fromIO<E, A>(io: IO<never, E, A>, scheduler?: SchedulerLike): Observable<E, A>;
+export declare function fromIO<R, E, A>(io: IO<R, E, A>, scheduler?: SchedulerLike): Observable<R, E, A>;
 /**
  * @tsplus static fncts.observable.ObservableOps unit
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare const unit: Observable<never, void>;
+export declare const unit: Observable<never, never, void>;
 /**
  * @tsplus fluent fncts.observable.Observable zipWith
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function zipWith<E, A, E1, B, C>(fa: Observable<E, A>, fb: Observable<E1, B>, f: (a: A, b: B) => C): Observable<E | E1, C>;
+export declare function zipWith<R, E, A, R1, E1, B, C>(fa: Observable<R, E, A>, fb: Observable<R1, E1, B>, f: (a: A, b: B) => C): Observable<R | R1, E | E1, C>;
 /**
  * @tsplus fluent fncts.observable.Observable zip
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function zip<E, A, E1, B>(fa: Observable<E, A>, fb: Observable<E1, B>): Observable<E | E1, readonly [A, B]>;
+export declare function zip<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, fb: Observable<R1, E1, B>): Observable<R | R1, E | E1, readonly [A, B]>;
 /**
  * @tsplus fluent fncts.observable.Observable ap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function ap<E, A, E1, B>(fab: Observable<E, (a: A) => B>, fa: Observable<E1, A>): Observable<E | E1, B>;
+export declare function ap<R, E, A, R1, E1, B>(fab: Observable<R, E, (a: A) => B>, fa: Observable<R1, E1, A>): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable mapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mapWithIndex<E, A, B>(fa: Observable<E, A>, f: (i: number, a: A) => B): Observable<E, B>;
+export declare function mapWithIndex<R, E, A, B>(fa: Observable<R, E, A>, f: (i: number, a: A) => B): Observable<R, E, B>;
 /**
  * @tsplus fluent fncts.observable.Observable map
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function map_<E, A, B>(fa: Observable<E, A>, f: (a: A) => B): Observable<E, B>;
+export declare function map_<R, E, A, B>(fa: Observable<R, E, A>, f: (a: A) => B): Observable<R, E, B>;
 /**
  * @tsplus fluent fncts.observable.Observable as
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function as_<E, A, B>(fa: Observable<E, A>, b: Lazy<B>): Observable<E, B>;
+export declare function as_<R, E, A, B>(fa: Observable<R, E, A>, b: Lazy<B>): Observable<R, E, B>;
 /**
  * @tsplus fluent fncts.observable.Observable mapError
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mapError_<E, A, E1>(fa: Observable<E, A>, f: (e: E) => E1): Observable<E1, A>;
+export declare function mapError_<R, E, A, E1>(fa: Observable<R, E, A>, f: (e: E) => E1): Observable<R, E1, A>;
 /**
  * @tsplus getter fncts.observable.Observable swap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function swap<E, A>(fa: Observable<E, A>): Observable<A, E>;
+export declare function swap<R, E, A>(fa: Observable<R, E, A>): Observable<R, A, E>;
 /**
  * @tsplus fluent fncts.observable.Observable filterWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function filterWithIndex_<E, A, B extends A>(fa: Observable<E, A>, refinement: RefinementWithIndex<number, A, B>): Observable<E, B>;
-export declare function filterWithIndex_<E, A>(fa: Observable<E, A>, predicate: PredicateWithIndex<number, A>): Observable<E, A>;
+export declare function filterWithIndex_<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: RefinementWithIndex<number, A, B>): Observable<R, E, B>;
+export declare function filterWithIndex_<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable filter
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function filter_<E, A, B extends A>(fa: Observable<E, A>, refinement: Refinement<A, B>): Observable<E, B>;
-export declare function filter_<E, A>(fa: Observable<E, A>, predicate: Predicate<A>): Observable<E, A>;
+export declare function filter_<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: Refinement<A, B>): Observable<R, E, B>;
+export declare function filter_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable filterMapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function filterMapWithIndex<E, A, B>(fa: Observable<E, A>, f: (i: number, a: A) => Maybe<B>): Observable<E, B>;
+export declare function filterMapWithIndex<R, E, A, B>(fa: Observable<R, E, A>, f: (i: number, a: A) => Maybe<B>): Observable<R, E, B>;
 /**
  * @tsplus fluent fncts.observable.Observable filterMap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function filterMap_<E, A, B>(fa: Observable<E, A>, f: (a: A) => Maybe<B>): Observable<E, B>;
+export declare function filterMap_<R, E, A, B>(fa: Observable<R, E, A>, f: (a: A) => Maybe<B>): Observable<R, E, B>;
 /**
  * @tsplus fluent fncts.observable.Observable partitionWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function partitionWithIndex<E, A, B extends A>(fa: Observable<E, A>, refinement: RefinementWithIndex<number, A, B>): readonly [Observable<E, Exclude<A, B>>, Observable<E, B>];
-export declare function partitionWithIndex<E, A>(fa: Observable<E, A>, predicate: PredicateWithIndex<number, A>): readonly [Observable<E, A>, Observable<E, A>];
+export declare function partitionWithIndex<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: RefinementWithIndex<number, A, B>): readonly [Observable<R, E, Exclude<A, B>>, Observable<R, E, B>];
+export declare function partitionWithIndex<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>): readonly [Observable<R, E, A>, Observable<R, E, A>];
 /**
  * @tsplus fluent fncts.observable.Observable partition
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function partition_<E, A, B extends A>(fa: Observable<E, A>, refinement: Refinement<A, B>): readonly [Observable<E, Exclude<A, B>>, Observable<E, B>];
-export declare function partition_<E, A>(fa: Observable<E, A>, predicate: Predicate<A>): readonly [Observable<E, A>, Observable<E, A>];
+export declare function partition_<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: Refinement<A, B>): readonly [Observable<R, E, Exclude<A, B>>, Observable<R, E, B>];
+export declare function partition_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): readonly [Observable<R, E, A>, Observable<R, E, A>];
 /**
  * @tsplus fluent fncts.observable.Observable partitionMapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function partitionMapWithIndex_<E, A, B, C>(fa: Observable<E, A>, f: (i: number, a: A) => Either<B, C>): readonly [Observable<E, B>, Observable<E, C>];
+export declare function partitionMapWithIndex_<R, E, A, B, C>(fa: Observable<R, E, A>, f: (i: number, a: A) => Either<B, C>): readonly [Observable<R, E, B>, Observable<R, E, C>];
 /**
  * @tsplus fluent fncts.observable.Observable partitionMap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function partitionMap_<E, A, B, C>(fa: Observable<E, A>, f: (a: A) => Either<B, C>): readonly [Observable<E, B>, Observable<E, C>];
+export declare function partitionMap_<R, E, A, B, C>(fa: Observable<R, E, A>, f: (a: A) => Either<B, C>): readonly [Observable<R, E, B>, Observable<R, E, C>];
+/**
+ * @tsplus fluent fncts.observable.Observable provideEnvironment
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function provideEnvironment<R, E, A>(self: Observable<R, E, A>, environment: Environment<R>): Observable<never, E, A>;
+/**
+ * @tsplus fluent fncts.observable.Observable provideService
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function provideService<R, E, A, S>(self: Observable<R, E, A>, service: S, 
+/** @tsplus auto */ tag: Tag<S>): Observable<Exclude<R, S>, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable mergeMapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mergeMapWithIndex<E, A, E1, B>(ma: Observable<E, A>, f: (i: number, a: A) => ObservableInput<E1, B>, concurrent?: number): Observable<E | E1, B>;
+export declare function mergeMapWithIndex<R, E, A, R1, E1, B>(ma: Observable<R, E, A>, f: (i: number, a: A) => ObservableInput<R1, E1, B>, concurrent?: number): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable mergeMap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mergeMap_<E, A, E1, B>(ma: Observable<E, A>, f: (a: A) => ObservableInput<E1, B>, concurrent?: number): Observable<E | E1, B>;
+export declare function mergeMap_<R, E, A, R1, E1, B>(ma: Observable<R, E, A>, f: (a: A) => ObservableInput<R1, E1, B>, concurrent?: number): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable concatMapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function concatMapWithIndex<E, A, E1, B>(ma: Observable<E, A>, f: (i: number, a: A) => ObservableInput<E1, B>): Observable<E | E1, B>;
+export declare function concatMapWithIndex<R, E, A, R1, E1, B>(ma: Observable<R, E, A>, f: (i: number, a: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable concatMap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function concatMap_<E, A, E1, B>(ma: Observable<E, A>, f: (a: A) => ObservableInput<E1, B>): Observable<E | E1, B>;
+export declare function concatMap_<R, E, A, R1, E1, B>(ma: Observable<R, E, A>, f: (a: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
+/**
+ * @tsplus fluent fncts.observable.Observable contramapEnvironment
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function contramapEnvironment<R, E, A, R0>(self: Observable<R, E, A>, f: (r0: Environment<R0>) => Environment<R>): Observable<R0, E, A>;
 /**
  * @tsplus getter fncts.observable.Observable flatten
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function flatten<E, E1, A>(mma: Observable<E, Observable<E1, A>>): Observable<E | E1, A>;
+export declare function flatten<R, E, R1, E1, A>(mma: Observable<R, E, Observable<R1, E1, A>>): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable foldLeftWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function foldLeftWithIndex<E, A, B>(fa: Observable<E, A>, initial: B, f: (index: number, acc: B, value: A) => B): Observable<E, B>;
+export declare function foldLeftWithIndex<R, E, A, B>(fa: Observable<R, E, A>, initial: B, f: (index: number, acc: B, value: A) => B): Observable<R, E, B>;
 /**
  * @tsplus fluent fncts.observable.Observable foldLeft
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function foldLeft<E, A, B>(fa: Observable<E, A>, initial: B, f: (acc: B, value: A) => B): Observable<E, B>;
+export declare function foldLeft<R, E, A, B>(fa: Observable<R, E, A>, initial: B, f: (acc: B, value: A) => B): Observable<R, E, B>;
 /**
  * @tsplus fluent fncts.observable.Observable at
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function at_<E, A>(fa: Observable<E, A>, index: number): Observable<E, Maybe<A>>;
+export declare function at_<R, E, A>(fa: Observable<R, E, A>, index: number): Observable<R, E, Maybe<A>>;
 /**
  * @tsplus fluent fncts.observable.Observable audit
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function audit_<E, A, E1>(fa: Observable<E, A>, durationSelector: (value: A) => ObservableInput<E1, any>): Observable<E | E1, A>;
+export declare function audit_<R, E, A, R1, E1>(fa: Observable<R, E, A>, durationSelector: (value: A) => ObservableInput<R1, E1, any>): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable auditTime
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function auditTime_<E, A>(fa: Observable<E, A>, duration: number, scheduler?: SchedulerLike): Observable<E, A>;
+export declare function auditTime_<R, E, A>(fa: Observable<R, E, A>, duration: number, scheduler?: SchedulerLike): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable buffer
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function buffer_<E, A, E1>(fa: Observable<E, A>, closingNotifier: Observable<E1, any>): Observable<E | E1, ReadonlyArray<A>>;
+export declare function buffer_<R, E, A, R1, E1>(fa: Observable<R, E, A>, closingNotifier: Observable<R1, E1, any>): Observable<R | R1, E | E1, ReadonlyArray<A>>;
 /**
  * @tsplus fluent fncts.observable.Observable bufferCount
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function bufferCount_<E, A>(fa: Observable<E, A>, bufferSize: number, startBufferEvery?: number): Observable<E, ReadonlyArray<A>>;
+export declare function bufferCount_<R, E, A>(fa: Observable<R, E, A>, bufferSize: number, startBufferEvery?: number): Observable<R, E, ReadonlyArray<A>>;
 export interface BufferTimeConfig {
     readonly bufferTimeSpan: number;
     readonly bufferCreationInterval?: number;
@@ -284,200 +307,202 @@ export interface BufferTimeConfig {
  * @tsplus fluent fncts.observable.Observable bufferTime
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function bufferTime_<E, A>(fa: Observable<E, A>, config: BufferTimeConfig): Observable<E, ReadonlyArray<A>>;
+export declare function bufferTime_<R, E, A>(fa: Observable<R, E, A>, config: BufferTimeConfig): Observable<R, E, ReadonlyArray<A>>;
 /**
  * @tsplus fluent fncts.observable.Observable bufferToggle
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function bufferToggle_<E, A, E1, B, E2>(fa: Observable<E, A>, openings: ObservableInput<E1, B>, closingSelector: (value: B) => ObservableInput<E2, any>): Observable<E | E1 | E2, ReadonlyArray<A>>;
+export declare function bufferToggle_<R, E, A, R1, E1, B, R2, E2>(fa: Observable<R, E, A>, openings: ObservableInput<R1, E1, B>, closingSelector: (value: B) => ObservableInput<R2, E2, any>): Observable<R | R1 | R2, E | E1 | E2, ReadonlyArray<A>>;
 /**
  * @tsplus fluent fncts.observable.Observable bufferWhen
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function bufferWhen_<E, A, E1>(fa: Observable<E, A>, closingSelector: () => ObservableInput<E1, any>): Observable<E | E1, ReadonlyArray<A>>;
-export declare function bufferWhen<E1>(closingSelector: () => ObservableInput<E1, any>): <E, A>(fa: Observable<E, A>) => Observable<E | E1, ReadonlyArray<A>>;
+export declare function bufferWhen_<R, E, A, R1, E1>(fa: Observable<R, E, A>, closingSelector: () => ObservableInput<R1, E1, any>): Observable<R | R1, E | E1, ReadonlyArray<A>>;
 /**
  * @tsplus fluent fncts.observable.Observable catchAllCause
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function catchAllCause<E, A, E1, B>(self: Observable<E, A>, f: (cause: Cause<E>, caught: Observable<E | E1, A | B>) => ObservableInput<E1, B>): Observable<E1, A | B>;
+export declare function catchAllCause<R, E, A, R1, E1, B>(self: Observable<R, E, A>, f: (cause: Cause<E>, caught: Observable<R | R1, E | E1, A | B>) => ObservableInput<R | R1, E1, B>): Observable<R | R1, E1, A | B>;
 /**
  * @tsplus getter fncts.observable.Observable concatAll
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function concatAll<E, E1, A>(ffa: Observable<E, ObservableInput<E1, A>>): Observable<E | E1, A>;
+export declare function concatAll<R, E, R1, E1, A>(ffa: Observable<R, E, ObservableInput<R1, E1, A>>): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable concat
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function concat_<E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(fa: Observable<E, A>, ...sources: O): Observable<E | Observable.ErrorOf<O[number]>, A | Observable.TypeOf<O[number]>>;
+export declare function concat_<R, E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(fa: Observable<R, E, A>, ...sources: O): Observable<R | Observable.EnvironmentOf<O[number]>, E | Observable.ErrorOf<O[number]>, A | Observable.TypeOf<O[number]>>;
 /**
  * @tsplus getter fncts.observable.Observable count
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function count<E, A>(fa: Observable<E, A>): Observable<E, number>;
+export declare function count<R, E, A>(fa: Observable<R, E, A>): Observable<R, E, number>;
 /**
  * @tsplus fluent fncts.observable.Observable countWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function countWithIndex<E, A>(fa: Observable<E, A>, predicate: PredicateWithIndex<number, A>): Observable<E, number>;
+export declare function countWithIndex<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>): Observable<R, E, number>;
 /**
  * @tsplus fluent fncts.observable.Observable countWith
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function countWith_<E, A>(fa: Observable<E, A>, predicate: Predicate<A>): Observable<E, number>;
+export declare function countWith_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, number>;
 /**
  * @tsplus getter fncts.observable.Observable combineLatestAll
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function combineLatestAll<E, E1, A>(fa: Observable<E, ObservableInput<E1, A>>): Observable<E | E1, ReadonlyArray<A>>;
+export declare function combineLatestAll<R, E, R1, E1, A>(fa: Observable<R, E, ObservableInput<R1, E1, A>>): Observable<R | R1, E | E1, ReadonlyArray<A>>;
 /**
  * @tsplus fluent fncts.observable.Observable combineLatest
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function combineLatest_<E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(self: ObservableInput<E, A>, ...sources: O): Observable<E | Observable.ErrorOf<O[number]>, [A, ...{
-    [K in keyof O]: Observable.TypeOf<O[K]>;
-}]>;
+export declare function combineLatest_<R, E, A, O extends ReadonlyArray<ObservableInput<any, any, any>>>(self: ObservableInput<R, E, A>, ...sources: O): Observable<R | Observable.EnvironmentOf<O[number]>, E | Observable.ErrorOf<O[number]>, [
+    A,
+    ...{
+        [K in keyof O]: Observable.TypeOf<O[K]>;
+    }
+]>;
 /**
  * @tsplus fluent fncts.observable.Observable debounceWith
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function debounceWith_<E, A, E1>(fa: Observable<E, A>, durationSelector: (value: A) => ObservableInput<E1, any>): Observable<E | E1, A>;
+export declare function debounceWith_<R, E, A, R1, E1>(fa: Observable<R, E, A>, durationSelector: (value: A) => ObservableInput<R1, E1, any>): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable debounce
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function debounce_<E, A>(fa: Observable<E, A>, dueTime: number, scheduler?: SchedulerLike): Observable<E, A>;
+export declare function debounce_<R, E, A>(fa: Observable<R, E, A>, dueTime: number, scheduler?: SchedulerLike): Observable<R, E, A>;
 /**
  * @tsplus getter fncts.observable.Observable either
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function either<E, A>(fa: Observable<E, A>): Observable<never, Either<E, A>>;
+export declare function either<R, E, A>(fa: Observable<R, E, A>): Observable<R, never, Either<E, A>>;
 /**
  * @tsplus fluent fncts.observable.Observable delayWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function delayWithIndex<E, A, E1>(fa: Observable<E, A>, f: (index: number, value: A) => Observable<E1, any>): Observable<E | E1, A>;
+export declare function delayWithIndex<R, E, A, R1, E1>(fa: Observable<R, E, A>, f: (index: number, value: A) => Observable<R1, E1, any>): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable delayWith
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function delayWith_<E, A, E1>(fa: Observable<E, A>, f: (value: A) => Observable<E1, any>): Observable<E | E1, A>;
+export declare function delayWith_<R, E, A, R1, E1>(fa: Observable<R, E, A>, f: (value: A) => Observable<R1, E1, any>): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable delay
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function delay_<E, A>(fa: Observable<E, A>, due: number | Date, scheduler?: SchedulerLike): Observable<E, A>;
+export declare function delay_<R, E, A>(fa: Observable<R, E, A>, due: number | Date, scheduler?: SchedulerLike): Observable<R, E, A>;
 /**
  * @tsplus getter fncts.observable.Observable dematerialize
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function dematerialize<E, E1, A>(fa: Observable<E, Notification<E1, A>>): Observable<E | E1, A>;
+export declare function dematerialize<R, E, E1, A>(fa: Observable<R, E, Notification<E1, A>>): Observable<R, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable ensuring
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function ensuring_<E, A>(fa: Observable<E, A>, finalizer: () => void): Observable<E, A>;
+export declare function ensuring_<R, E, A>(fa: Observable<R, E, A>, finalizer: () => void): Observable<R, E, A>;
 /**
  * @tsplus getter fncts.observable.Observable exhaustAll
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function exhaustAll<E, E1, A>(ffa: Observable<E, ObservableInput<E1, A>>): Observable<E | E1, A>;
+export declare function exhaustAll<R, E, R1, E1, A>(ffa: Observable<R, E, ObservableInput<R1, E1, A>>): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable exhaustMapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function exhaustMapWithIndex<E, A, E1, B>(self: Observable<E, A>, f: (i: number, a: A) => ObservableInput<E1, B>): Observable<E | E1, B>;
+export declare function exhaustMapWithIndex<R, E, A, R1, E1, B>(self: Observable<R, E, A>, f: (i: number, a: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable exhaustMap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function exhaustMap_<E, A, E1, B>(self: Observable<E, A>, f: (a: A) => ObservableInput<E1, B>): Observable<E | E1, B>;
+export declare function exhaustMap_<R, E, A, R1, E1, B>(self: Observable<R, E, A>, f: (a: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable expandWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function expandWithIndex<E, A, E1, B>(fa: Observable<E, A>, f: (i: number, a: A) => ObservableInput<E1, B>, concurrent?: number): Observable<E | E1, B>;
+export declare function expandWithIndex<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, f: (i: number, a: A) => ObservableInput<R1, E1, B>, concurrent?: number): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable expand
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function expand_<E, A, E1, B>(fa: Observable<E, A>, f: (a: A) => ObservableInput<E1, B>, concurrent?: number): Observable<E | E1, B>;
+export declare function expand_<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, f: (a: A) => ObservableInput<R1, E1, B>, concurrent?: number): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable findWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function findWithIndex<E, A, B extends A>(fa: Observable<E, A>, refinement: RefinementWithIndex<number, A, B>): Observable<E, Maybe<B>>;
-export declare function findWithIndex<E, A>(fa: Observable<E, A>, predicate: PredicateWithIndex<number, A>): Observable<E, Maybe<A>>;
+export declare function findWithIndex<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: RefinementWithIndex<number, A, B>): Observable<R, E, Maybe<B>>;
+export declare function findWithIndex<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>): Observable<R, E, Maybe<A>>;
 /**
  * @tsplus fluent fncts.observable.Observable find
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function find_<E, A, B extends A>(fa: Observable<E, A>, refinement: Refinement<A, B>): Observable<E, Maybe<B>>;
-export declare function find_<E, A>(fa: Observable<E, A>, predicate: Predicate<A>): Observable<E, Maybe<A>>;
+export declare function find_<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: Refinement<A, B>): Observable<R, E, Maybe<B>>;
+export declare function find_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, Maybe<A>>;
 /**
  * @tsplus fluent fncts.observable.Observable findIndexWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function findIndexWithIndex<E, A, B extends A>(fa: Observable<E, A>, refinement: RefinementWithIndex<number, A, B>): Observable<E, number>;
-export declare function findIndexWithIndex<E, A>(fa: Observable<E, A>, predicate: PredicateWithIndex<number, A>): Observable<E, number>;
+export declare function findIndexWithIndex<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: RefinementWithIndex<number, A, B>): Observable<R, E, number>;
+export declare function findIndexWithIndex<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>): Observable<R, E, number>;
 /**
  * @tsplus fluent fncts.observable.Observable findIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function findIndex_<E, A, B extends A>(fa: Observable<E, A>, refinement: Refinement<A, B>): Observable<E, number>;
-export declare function findIndex_<E, A>(fa: Observable<E, A>, predicate: Predicate<A>): Observable<E, number>;
+export declare function findIndex_<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: Refinement<A, B>): Observable<R, E, number>;
+export declare function findIndex_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>): Observable<R, E, number>;
 /**
  * @tsplus static fncts.observable.ObservableOps forkJoin
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function forkJoin<S extends Record<string, ObservableInput<any, any>>>(sources: S): Observable<Observable.ErrorOf<S[keyof S]>, {
+export declare function forkJoin<S extends Record<string, ObservableInput<any, any>>>(sources: S): Observable<Observable.EnvironmentOf<S[keyof S]>, Observable.ErrorOf<S[keyof S]>, {
     [K in keyof S]: Observable.TypeOf<S[K]>;
 }>;
-export declare function forkJoin<A extends ReadonlyArray<ObservableInput<any, any>>>(...sources: A): Observable<Observable.ErrorOf<A[number]>, {
+export declare function forkJoin<A extends ReadonlyArray<ObservableInput<any, any>>>(...sources: A): Observable<Observable.EnvironmentOf<A[number]>, Observable.ErrorOf<A[number]>, {
     [K in keyof A]: Observable.TypeOf<A[K]>;
 }>;
 /**
  * @tsplus getter fncts.observable.Observable ignore
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function ignore<E, A>(fa: Observable<E, A>): Observable<E, never>;
+export declare function ignore<R, E, A>(fa: Observable<R, E, A>): Observable<R, E, never>;
 /**
  * @tsplus getter fncts.observable.Observable isEmpty
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function isEmpty<E, A>(fa: Observable<E, A>): Observable<E, boolean>;
+export declare function isEmpty<R, E, A>(fa: Observable<R, E, A>): Observable<R, E, boolean>;
 /**
  * @tsplus getter fncts.observable.Observable materialize
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function materialize<E, A>(fa: Observable<E, A>): Observable<never, Notification<E, A>>;
+export declare function materialize<R, E, A>(fa: Observable<R, E, A>): Observable<R, never, Notification<E, A>>;
 /**
  * @tsplus fluent fncts.observable.Observable mergeAll
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mergeAll_<E, E1, A>(self: Observable<E, ObservableInput<E1, A>>, concurrent?: number): Observable<E | E1, A>;
+export declare function mergeAll_<R, E, R1, E1, A>(self: Observable<R, E, ObservableInput<R1, E1, A>>, concurrent?: number): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable mergeScanWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mergeScanWithIndex<E, A, E1, B>(fa: Observable<E, A>, initial: B, f: (index: number, acc: B, value: A) => ObservableInput<E1, B>, concurrent?: number): Observable<E | E1, B>;
+export declare function mergeScanWithIndex<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, initial: B, f: (index: number, acc: B, value: A) => ObservableInput<R1, E1, B>, concurrent?: number): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable mergeScan
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function mergeScan_<E, A, E1, B>(fa: Observable<E, A>, initial: B, f: (acc: B, value: A) => ObservableInput<E1, B>, concurrent?: number): Observable<E | E1, B>;
-export declare function onErrorResumeNext<E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(fa: Observable<E, A>, ...sources: O): Observable<E | Observable.ErrorOf<O[number]>, A | Observable.TypeOf<O[number]>>;
+export declare function mergeScan_<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, initial: B, f: (acc: B, value: A) => ObservableInput<R1, E1, B>, concurrent?: number): Observable<R | R1, E | E1, B>;
+export declare function onErrorResumeNext<R, E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(fa: Observable<R, E, A>, ...sources: O): Observable<R | Observable.EnvironmentOf<O[number]>, E | Observable.ErrorOf<O[number]>, A | Observable.TypeOf<O[number]>>;
 /**
  * @tsplus fluent fncts.observable.Observable onEmpty
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function onEmpty_<E, A, B>(fa: Observable<E, A>, f: Lazy<B>): Observable<E, A | B>;
+export declare function onEmpty_<R, E, A, B>(fa: Observable<R, E, A>, f: Lazy<B>): Observable<R, E, A | B>;
 /**
  * @tsplus fluent fncts.observable.Observable repeat
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function repeat_<E, A>(fa: Observable<E, A>, count?: number): Observable<E, A>;
+export declare function repeat_<R, E, A>(fa: Observable<R, E, A>, count?: number): Observable<R, E, A>;
 export interface RetryConfig {
     readonly count: number;
     readonly resetOnSuccess?: boolean;
@@ -486,115 +511,131 @@ export interface RetryConfig {
  * @tsplus fluent fncts.observable.Observable retry
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function retry_<E, A>(fa: Observable<E, A>, count?: number): Observable<E, A>;
-export declare function retry_<E, A>(fa: Observable<E, A>, config: RetryConfig): Observable<E, A>;
+export declare function retry_<R, E, A>(fa: Observable<R, E, A>, count?: number): Observable<R, E, A>;
+export declare function retry_<R, E, A>(fa: Observable<R, E, A>, config: RetryConfig): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable sample
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function sample_<E, A, E1>(fa: Observable<E, A>, notifier: Observable<E1, any>): Observable<E | E1, A>;
+export declare function sample_<R, E, A, R1, E1>(fa: Observable<R, E, A>, notifier: Observable<R1, E1, any>): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable sampleTime
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function sampleTime_<E, A>(fa: Observable<E, A>, period: number, scheduler?: SchedulerLike): Observable<E, A>;
+export declare function sampleTime_<R, E, A>(fa: Observable<R, E, A>, period: number, scheduler?: SchedulerLike): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable scanLeftWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function scanLeftWithIndex<E, A, B>(fa: Observable<E, A>, initial: B, f: (index: number, acc: B, value: A) => B): Observable<E, B>;
+export declare function scanLeftWithIndex<R, E, A, B>(fa: Observable<R, E, A>, initial: B, f: (index: number, acc: B, value: A) => B): Observable<R, E, B>;
 /**
  * @tsplus fluent fncts.observable.Observable scanLeft
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function scanLeft<E, A, B>(fa: Observable<E, A>, initial: B, f: (acc: B, value: A) => B): Observable<E, B>;
+export declare function scanLeft<R, E, A, B>(fa: Observable<R, E, A>, initial: B, f: (acc: B, value: A) => B): Observable<R, E, B>;
+/**
+ * @tsplus static fncts.observable.ObservableOps service
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function service<S>(/** @tsplus auto */ tag: Tag<S>): Observable<S, never, S>;
+/**
+ * @tsplus static fncts.observable.ObservableOps serviceWith
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function serviceWith<S, A>(f: (service: S) => A, /** @tsplus auto */ tag: Tag<S>): Observable<S, never, A>;
+/**
+ * @tsplus static fncts.observable.ObservableOps serviceWithObservable
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function serviceWithObservable<S, R, E, A>(f: (service: S) => Observable<R, E, A>, 
+/** @tsplus auto */ tag: Tag<S>): Observable<S | R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable skip
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function skip_<E, A>(fa: Observable<E, A>, count: number): Observable<E, A>;
+export declare function skip_<R, E, A>(fa: Observable<R, E, A>, count: number): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable skipLast
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function skipLast_<E, A>(fa: Observable<E, A>, skipCount: number): Observable<E, A>;
+export declare function skipLast_<R, E, A>(fa: Observable<R, E, A>, skipCount: number): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable skipUntil
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function skipUntil_<E, A, E1>(fa: Observable<E, A>, notifier: Observable<E1, any>): Observable<E | E1, A>;
+export declare function skipUntil_<R, E, A, R1, E1>(fa: Observable<R, E, A>, notifier: Observable<R1, E1, any>): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable skipWhile
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function skipWhile_<E, A>(fa: Observable<E, A>, predicate: PredicateWithIndex<number, A>): Observable<E, A>;
+export declare function skipWhile_<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable startWith
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function startWith_<E, A, B extends ReadonlyArray<unknown>>(fa: Observable<E, A>, ...values: B): Observable<E, A | B[number]>;
+export declare function startWith_<R, E, A, B extends ReadonlyArray<unknown>>(fa: Observable<R, E, A>, ...values: B): Observable<R, E, A | B[number]>;
 /**
  * @tsplus fluent fncts.observable.Observable subscribeOn
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function subscribeOn_<E, A>(fa: Observable<E, A>, scheduler: SchedulerLike, delay?: number): Observable<E, A>;
+export declare function subscribeOn_<R, E, A>(fa: Observable<R, E, A>, scheduler: SchedulerLike, delay?: number): Observable<R, E, A>;
 /**
  * @tsplus getter fncts.observable.Observable switchAll
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function switchAll<E, E1, A>(ffa: Observable<E, ObservableInput<E1, A>>): Observable<E | E1, A>;
+export declare function switchAll<R, E, R1, E1, A>(ffa: Observable<R, E, ObservableInput<R1, E1, A>>): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable switchMapWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function switchMapWithIndex<E, A, E1, B>(fa: Observable<E, A>, f: (index: number, value: A) => ObservableInput<E1, B>): Observable<E | E1, B>;
+export declare function switchMapWithIndex<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, f: (index: number, value: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable switchMap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function switchMap_<E, A, E1, B>(fa: Observable<E, A>, f: (value: A) => ObservableInput<E1, B>): Observable<E | E1, B>;
+export declare function switchMap_<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, f: (value: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable switchScanWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function switchScanWithIndex<E, A, E1, B>(fa: Observable<E, A>, initial: B, f: (index: number, acc: B, value: A) => ObservableInput<E1, B>): Observable<E | E1, B>;
+export declare function switchScanWithIndex<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, initial: B, f: (index: number, acc: B, value: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable switchScan
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function switchScan_<E, A, E1, B>(fa: Observable<E, A>, initial: B, f: (acc: B, value: A) => ObservableInput<E1, B>): Observable<E | E1, B>;
+export declare function switchScan_<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, initial: B, f: (acc: B, value: A) => ObservableInput<R1, E1, B>): Observable<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.observable.Observable take
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function take_<E, A>(fa: Observable<E, A>, count: number): Observable<E, A>;
+export declare function take_<R, E, A>(fa: Observable<R, E, A>, count: number): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable takeLast
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function takeLast_<E, A>(fa: Observable<E, A>, count: number): Observable<E, A>;
+export declare function takeLast_<R, E, A>(fa: Observable<R, E, A>, count: number): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable takeUntil
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function takeUntil_<E, A, E1>(fa: Observable<E, A>, notifier: ObservableInput<E1, any>): Observable<E | E1, A>;
+export declare function takeUntil_<R, E, A, R1, E1>(fa: Observable<R, E, A>, notifier: ObservableInput<R1, E1, any>): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable takeWhileWithIndex
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function takeWhileWithIndex<E, A, B extends A>(fa: Observable<E, A>, refinement: RefinementWithIndex<number, A, B>, inclusive?: boolean): Observable<E, B>;
-export declare function takeWhileWithIndex<E, A>(fa: Observable<E, A>, predicate: PredicateWithIndex<number, A>, inclusive?: boolean): Observable<E, A>;
+export declare function takeWhileWithIndex<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: RefinementWithIndex<number, A, B>, inclusive?: boolean): Observable<R, E, B>;
+export declare function takeWhileWithIndex<R, E, A>(fa: Observable<R, E, A>, predicate: PredicateWithIndex<number, A>, inclusive?: boolean): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable takeWhile
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function takeWhile_<E, A, B extends A>(fa: Observable<E, A>, refinement: Refinement<A, B>, inclusive?: boolean): Observable<E, B>;
-export declare function takeWhile_<E, A>(fa: Observable<E, A>, predicate: Predicate<A>, inclusive?: boolean): Observable<E, A>;
+export declare function takeWhile_<R, E, A, B extends A>(fa: Observable<R, E, A>, refinement: Refinement<A, B>, inclusive?: boolean): Observable<R, E, B>;
+export declare function takeWhile_<R, E, A>(fa: Observable<R, E, A>, predicate: Predicate<A>, inclusive?: boolean): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable tap
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function tap_<E, A>(fa: Observable<E, A>, observer: Partial<Observer<E, A>>): Observable<E, A>;
+export declare function tap_<R, E, A>(fa: Observable<R, E, A>, observer: Partial<Observer<E, A>>): Observable<R, E, A>;
 export interface ThrottleConfig {
     readonly leading?: boolean;
     readonly trailing?: boolean;
@@ -604,13 +645,13 @@ export declare const defaultThrottleConfig: ThrottleConfig;
  * @tsplus fluent fncts.observable.Observable throttle
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function throttle_<E, A, E1>(fa: Observable<E, A>, durationSelector: (a: A) => ObservableInput<E1, any>, { leading, trailing }?: ThrottleConfig): Observable<E | E1, A>;
+export declare function throttle_<R, E, A, R1, E1>(fa: Observable<R, E, A>, durationSelector: (a: A) => ObservableInput<R1, E1, any>, { leading, trailing }?: ThrottleConfig): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable throttleTime
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function throttleTime_<E, A>(fa: Observable<E, A>, duration: number, scheduler?: SchedulerLike, config?: ThrottleConfig): Observable<E, A>;
-export declare type TimeoutConfig<A, E, B, M = unknown> = ({
+export declare function throttleTime_<R, E, A>(fa: Observable<R, E, A>, duration: number, scheduler?: SchedulerLike, config?: ThrottleConfig): Observable<R, E, A>;
+export declare type TimeoutConfig<R, E, A, B, M = unknown> = ({
     readonly each: number;
     readonly first?: number | Date;
 } | {
@@ -618,7 +659,7 @@ export declare type TimeoutConfig<A, E, B, M = unknown> = ({
     readonly first: number | Date;
 }) & {
     readonly scheduler?: SchedulerLike;
-    readonly with?: (info: TimeoutInfo<A, M>) => ObservableInput<E, B>;
+    readonly with?: (info: TimeoutInfo<A, M>) => ObservableInput<R, E, B>;
     meta?: M;
 };
 export interface TimeoutInfo<A, M> {
@@ -634,34 +675,34 @@ export declare class TimeoutError<A, M> extends Error {
  * @tsplus fluent fncts.observable.Observable timeout
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function timeout_<E, A, E1, B, M = unknown>(fa: Observable<E, A>, config: TimeoutConfig<A, E1, B, M> & {
-    readonly with: (info: TimeoutInfo<A, M>) => ObservableInput<E1, B>;
-}): Observable<E | E1, A | B>;
-export declare function timeout_<E, A, M = unknown>(fa: Observable<E, A>, config: Omit<TimeoutConfig<A, never, any, M>, "with">): Observable<E | TimeoutError<A, M>, A>;
+export declare function timeout_<R, E, A, R1, E1, B, M = unknown>(fa: Observable<R, E, A>, config: TimeoutConfig<R1, E1, A, B, M> & {
+    readonly with: (info: TimeoutInfo<A, M>) => ObservableInput<R1, E1, B>;
+}): Observable<R | R1, E | E1, A | B>;
+export declare function timeout_<R, E, A, M = unknown>(fa: Observable<R, E, A>, config: Omit<TimeoutConfig<never, never, A, any, M>, "with">): Observable<R, E | TimeoutError<A, M>, A>;
 /**
  * @tsplus getter fncts.observable.Observable toArray
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function toArray<E, A>(fa: Observable<E, A>): Observable<E, ReadonlyArray<A>>;
+export declare function toArray<R, E, A>(fa: Observable<R, E, A>): Observable<R, E, ReadonlyArray<A>>;
 /**
  * @tsplus fluent fncts.observable.Observable unique
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function unique_<E, A, K, E1 = never>(fa: Observable<E, A>, toKey?: (value: A) => K, flushes?: Observable<E1, any>): Observable<E | E1, A>;
+export declare function unique_<R, E, A, K, R1, E1 = never>(fa: Observable<R, E, A>, toKey?: (value: A) => K, flushes?: Observable<R1, E1, any>): Observable<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.observable.Observable uniqueUntilChanged
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function uniqueUntilChanged_<E, A, K>(fa: Observable<E, A>, E: Eq<K>, keySelector: (value: A) => K): Observable<E, A>;
-export declare function uniqueUntilChanged_<E, A, K>(fa: Observable<E, A>, equals: (x: K, y: K) => boolean, keySelector: (value: A) => K): Observable<E, A>;
-export declare function uniqueUntilChanged_<E, A>(fa: Observable<E, A>, E: Eq<A>): Observable<E, A>;
-export declare function uniqueUntilChanged_<E, A>(fa: Observable<E, A>, equals: (x: A, y: A) => boolean): Observable<E, A>;
+export declare function uniqueUntilChanged_<R, E, A, K>(fa: Observable<R, E, A>, E: Eq<K>, keySelector: (value: A) => K): Observable<R, E, A>;
+export declare function uniqueUntilChanged_<R, E, A, K>(fa: Observable<R, E, A>, equals: (x: K, y: K) => boolean, keySelector: (value: A) => K): Observable<R, E, A>;
+export declare function uniqueUntilChanged_<R, E, A>(fa: Observable<R, E, A>, E: Eq<A>): Observable<R, E, A>;
+export declare function uniqueUntilChanged_<R, E, A>(fa: Observable<R, E, A>, equals: (x: A, y: A) => boolean): Observable<R, E, A>;
 /**
  * @tsplus fluent fncts.observable.Observable uniqueUntilKeyChanged
  * @tsplus location "@fncts/observable/Observable/api"
  */
-export declare function uniqueUntilKeyChanged_<E, A, K extends keyof A>(fa: Observable<E, A>, key: K, E: Eq<A[K]>): Observable<E, A>;
-export declare function uniqueUntilKeyChanged_<E, A, K extends keyof A>(fa: Observable<E, A>, key: K, equals: (x: A[K], y: A[K]) => boolean): Observable<E, A>;
-export declare function joinAllInternal<E, E1, A, E2, B>(fa: Observable<E, ObservableInput<E1, A>>, joiner: (sources: ReadonlyArray<ObservableInput<E1, A>>) => Observable<E2, B>): Observable<E | E1 | E2, B>;
-export declare function scanInternal<E, A, B>(f: (index: number, acc: A, value: A) => B, initial: B, hasInitial: false, emitOnNext: boolean, emitBeforeComplete?: undefined | true): (source: Observable<E, A>, subscriber: Subscriber<any, any>) => void;
-export declare function scanInternal<E, A, B>(f: (index: number, acc: B, value: A) => B, initial: B, hasInitial: true, emitOnNext: boolean, emitBeforeComplete?: undefined | true): (source: Observable<E, A>, subscriber: Subscriber<any, any>) => void;
+export declare function uniqueUntilKeyChanged_<R, E, A, K extends keyof A>(fa: Observable<R, E, A>, key: K, E: Eq<A[K]>): Observable<R, E, A>;
+export declare function uniqueUntilKeyChanged_<R, E, A, K extends keyof A>(fa: Observable<R, E, A>, key: K, equals: (x: A[K], y: A[K]) => boolean): Observable<R, E, A>;
+export declare function joinAllInternal<R, E, R1, E1, A, R2, E2, B>(fa: Observable<R, E, ObservableInput<R1, E1, A>>, joiner: (sources: ReadonlyArray<ObservableInput<R1, E1, A>>) => Observable<R2, E2, B>): Observable<R | R1 | R2, E | E1 | E2, B>;
+export declare function scanInternal<R, E, A, B>(f: (index: number, acc: A, value: A) => B, initial: B, hasInitial: false, emitOnNext: boolean, emitBeforeComplete?: undefined | true): (source: Observable<R, E, A>, subscriber: Subscriber<any, any>) => void;
+export declare function scanInternal<R, E, A, B>(f: (index: number, acc: B, value: A) => B, initial: B, hasInitial: true, emitOnNext: boolean, emitBeforeComplete?: undefined | true): (source: Observable<R, E, A>, subscriber: Subscriber<any, any>) => void;