@fncts/observable 0.0.1

package/Observable/api.d.ts

@@ -0,0 +1,668 @@
+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 { IOEnv } from "@fncts/io/IOEnv";
+import { Lazy } from "@fncts/base/data/function";
+import { Cause } from "@fncts/base/data/Cause";
+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 { Eq } from "@fncts/base/typeclass";
+import { Notification } from "@fncts/observable/Notification";
+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<IOEnv, E, A>;
+/**
+ * @tsplus static fncts.observable.ObservableOps halt
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function halt(defect: unknown): Observable<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>;
+/**
+ * @tsplus static fncts.observable.ObservableOps empty
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function empty<A>(): Observable<never, A>;
+/**
+ * @tsplus static fncts.observable.ObservableOps failCause
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function failCause<E>(cause: Cause<E>): Observable<E, never>;
+/**
+ * @tsplus static fncts.observable.ObservableOps fail
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function fail<E>(e: E): Observable<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>;
+/**
+ * @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 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>;
+export { _if as if };
+export interface IterateOptions<S> {
+    readonly initialState: S;
+    readonly cont?: (state: S) => boolean;
+    readonly iterate: (state: S) => S;
+    readonly scheduler?: SchedulerLike;
+}
+export declare function iterate<S>(options: IterateOptions<S>): Observable<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>;
+/**
+ * @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]>>;
+/**
+ * @tsplus static fncts.observable.ObservableOps of
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function of<A>(...items: ReadonlyArray<A>): Observable<never, A>;
+/**
+ * @tsplus static fncts.observable.ObservableOps single
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare function single<A>(a: A): Observable<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>;
+/**
+ * @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>;
+/**
+ * @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]>, {
+    [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<unknown, E, A>, scheduler?: SchedulerLike): Observable<E, A>;
+/**
+ * @tsplus static fncts.observable.ObservableOps unit
+ * @tsplus location "@fncts/observable/Observable/api"
+ */
+export declare const unit: Observable<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>;
+/**
+ * @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]>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>];
+/**
+ * @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>];
+/**
+ * @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>];
+/**
+ * @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>];
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>>;
+/**
+ * @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 interface BufferTimeConfig {
+    readonly bufferTimeSpan: number;
+    readonly bufferCreationInterval?: number;
+    readonly maxBufferSize?: number;
+    readonly scheduler?: SchedulerLike;
+}
+/**
+ * @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>>;
+/**
+ * @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>>;
+/**
+ * @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>>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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]>>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>>;
+/**
+ * @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]>;
+}]>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>>;
+/**
+ * @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>>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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]>, {
+    [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]>, {
+    [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>;
+/**
+ * @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>;
+/**
+ * @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>>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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]>>;
+/**
+ * @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>;
+/**
+ * @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 interface RetryConfig {
+    readonly count: number;
+    readonly resetOnSuccess?: boolean;
+}
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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]>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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 interface ThrottleConfig {
+    readonly leading?: boolean;
+    readonly trailing?: boolean;
+}
+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>;
+/**
+ * @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> = ({
+    readonly each: number;
+    readonly first?: number | Date;
+} | {
+    readonly each?: number;
+    readonly first: number | Date;
+}) & {
+    readonly scheduler?: SchedulerLike;
+    readonly with?: (info: TimeoutInfo<A, M>) => ObservableInput<E, B>;
+    meta?: M;
+};
+export interface TimeoutInfo<A, M> {
+    readonly meta?: M;
+    readonly seen: number;
+    readonly lastValue: Maybe<A>;
+}
+export declare class TimeoutError<A, M> extends Error {
+    readonly info: TimeoutInfo<A, M> | null;
+    constructor(info: TimeoutInfo<A, M> | null);
+}
+/**
+ * @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>;
+/**
+ * @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>>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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;