ZTSignal

abstract class ZTSignal<T> : Observable<T>

ZTSignal

Author

Alexandre Lemoult <a.lemoult@zhortech.com>

Constructors

ZTSignal

fun ZTSignal()

Functions

all

@CheckReturnValue()

@SchedulerSupport(value = none)

fun all(p0: Predicate<in T>): Single<Boolean>

ambWith

@CheckReturnValue()

@SchedulerSupport(value = none)

fun ambWith(p0: ObservableSource<out T>): Observable<T>

any

@CheckReturnValue()

@SchedulerSupport(value = none)

fun any(p0: Predicate<in T>): Single<Boolean>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> as(@NonNull() p0: ObservableConverter<T, out R>): R

blockingFirst

@CheckReturnValue()

@SchedulerSupport(value = none)

fun blockingFirst(): T

@CheckReturnValue()

@SchedulerSupport(value = none)

fun blockingFirst(p0: T): T

blockingForEach

@SchedulerSupport(value = none)

fun blockingForEach(p0: Consumer<in T>)

blockingIterable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun blockingIterable(): MutableIterable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun blockingIterable(p0: Int): MutableIterable<T>

blockingLast

@CheckReturnValue()

@SchedulerSupport(value = none)

fun blockingLast(): T

@CheckReturnValue()

@SchedulerSupport(value = none)

fun blockingLast(p0: T): T

blockingLatest

@CheckReturnValue()

@SchedulerSupport(value = none)

fun blockingLatest(): MutableIterable<T>

blockingMostRecent

@CheckReturnValue()

@SchedulerSupport(value = none)

fun blockingMostRecent(p0: T): MutableIterable<T>

blockingNext

@CheckReturnValue()

@SchedulerSupport(value = none)

fun blockingNext(): MutableIterable<T>

blockingSingle

@CheckReturnValue()

@SchedulerSupport(value = none)

fun blockingSingle(): T

@CheckReturnValue()

@SchedulerSupport(value = none)

fun blockingSingle(p0: T): T

blockingSubscribe

@SchedulerSupport(value = none)

fun blockingSubscribe()

@SchedulerSupport(value = none)

fun blockingSubscribe(p0: Observer<in T>)

@SchedulerSupport(value = none)

fun blockingSubscribe(p0: Consumer<in T>)

@SchedulerSupport(value = none)

fun blockingSubscribe(p0: Consumer<in T>, p1: Consumer<in Throwable>)

@SchedulerSupport(value = none)

fun blockingSubscribe(p0: Consumer<in T>, p1: Consumer<in Throwable>, p2: Action)

buffer

@CheckReturnValue()

@SchedulerSupport(value = none)

fun buffer(p0: ObservableSource): Observable<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun buffer(p0: Callable<out ObservableSource>): Observable<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun buffer(p0: Int): Observable<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <TOpening : Any, TClosing : Any> buffer(p0: ObservableSource<out TOpening>, p1: Function<in TOpening, out ObservableSource<out TClosing>>): Observable<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun > buffer(p0: ObservableSource, p1: Callable): Observable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun buffer(p0: ObservableSource, p1: Int): Observable<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun > buffer(p0: Callable<out ObservableSource>, p1: Callable): Observable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun > buffer(p0: Int, p1: Callable): Observable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun buffer(p0: Int, p1: Int): Observable<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun buffer(p0: Long, p1: TimeUnit): Observable<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <TOpening : Any, TClosing : Any, U : MutableCollection<in T>> buffer(p0: ObservableSource<out TOpening>, p1: Function<in TOpening, out ObservableSource<out TClosing>>, p2: Callable): Observable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun > buffer(p0: Int, p1: Int, p2: Callable): Observable

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun buffer(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun buffer(p0: Long, p1: TimeUnit, p2: Int): Observable<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun buffer(p0: Long, p1: Long, p2: TimeUnit): Observable<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun buffer(p0: Long, p1: TimeUnit, p2: Scheduler, p3: Int): Observable<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun buffer(p0: Long, p1: Long, p2: TimeUnit, p3: Scheduler): Observable<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun > buffer(p0: Long, p1: Long, p2: TimeUnit, p3: Scheduler, p4: Callable): Observable

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun > buffer(p0: Long, p1: TimeUnit, p2: Scheduler, p3: Int, p4: Callable, p5: Boolean): Observable

cache

@CheckReturnValue()

@SchedulerSupport(value = none)

fun cache(): Observable<T>

cacheWithInitialCapacity

@CheckReturnValue()

@SchedulerSupport(value = none)

fun cacheWithInitialCapacity(p0: Int): Observable<T>

cast

@CheckReturnValue()

@SchedulerSupport(value = none)

fun cast(p0: Class): Observable

collect

@CheckReturnValue()

@SchedulerSupport(value = none)

fun collect(p0: Callable<out U>, p1: BiConsumer<in U, in T>): Single

collectInto

@CheckReturnValue()

@SchedulerSupport(value = none)

fun collectInto(p0: U, p1: BiConsumer<in U, in T>): Single

compose

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> compose(p0: ObservableTransformer<in T, out R>): Observable<R>

concatMap

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMap(p0: Function<in T, out ObservableSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMap(p0: Function<in T, out ObservableSource<out R>>, p1: Int): Observable<R>

concatMapCompletable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun concatMapCompletable(p0: Function<in T, out CompletableSource>): Completable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun concatMapCompletable(p0: Function<in T, out CompletableSource>, p1: Int): Completable

concatMapCompletableDelayError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun concatMapCompletableDelayError(p0: Function<in T, out CompletableSource>): Completable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun concatMapCompletableDelayError(p0: Function<in T, out CompletableSource>, p1: Boolean): Completable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun concatMapCompletableDelayError(p0: Function<in T, out CompletableSource>, p1: Boolean, p2: Int): Completable

concatMapDelayError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapDelayError(p0: Function<in T, out ObservableSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapDelayError(p0: Function<in T, out ObservableSource<out R>>, p1: Int, p2: Boolean): Observable<R>

concatMapEager

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapEager(p0: Function<in T, out ObservableSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapEager(p0: Function<in T, out ObservableSource<out R>>, p1: Int, p2: Int): Observable<R>

concatMapEagerDelayError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapEagerDelayError(p0: Function<in T, out ObservableSource<out R>>, p1: Boolean): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapEagerDelayError(p0: Function<in T, out ObservableSource<out R>>, p1: Int, p2: Int, p3: Boolean): Observable<R>

concatMapIterable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun concatMapIterable(p0: Function<in T, out MutableIterable>): Observable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun concatMapIterable(p0: Function<in T, out MutableIterable>, p1: Int): Observable

concatMapMaybe

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapMaybe(p0: Function<in T, out MaybeSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapMaybe(p0: Function<in T, out MaybeSource<out R>>, p1: Int): Observable<R>

concatMapMaybeDelayError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapMaybeDelayError(p0: Function<in T, out MaybeSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapMaybeDelayError(p0: Function<in T, out MaybeSource<out R>>, p1: Boolean): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapMaybeDelayError(p0: Function<in T, out MaybeSource<out R>>, p1: Boolean, p2: Int): Observable<R>

concatMapSingle

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapSingle(p0: Function<in T, out SingleSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapSingle(p0: Function<in T, out SingleSource<out R>>, p1: Int): Observable<R>

concatMapSingleDelayError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapSingleDelayError(p0: Function<in T, out SingleSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapSingleDelayError(p0: Function<in T, out SingleSource<out R>>, p1: Boolean): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> concatMapSingleDelayError(p0: Function<in T, out SingleSource<out R>>, p1: Boolean, p2: Int): Observable<R>

concatWith

@CheckReturnValue()

@SchedulerSupport(value = none)

fun concatWith(@NonNull() p0: CompletableSource): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun concatWith(@NonNull() p0: MaybeSource<out T>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun concatWith(p0: ObservableSource<out T>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun concatWith(@NonNull() p0: SingleSource<out T>): Observable<T>

contains

@CheckReturnValue()

@SchedulerSupport(value = none)

fun contains(p0: Any): Single<Boolean>

count

@CheckReturnValue()

@SchedulerSupport(value = none)

fun count(): Single<Long>

debounce

@CheckReturnValue()

@SchedulerSupport(value = none)

fun debounce(p0: Function<in T, out ObservableSource>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun debounce(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun debounce(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

defaultIfEmpty

@CheckReturnValue()

@SchedulerSupport(value = none)

fun defaultIfEmpty(p0: T): Observable<T>

delay

@CheckReturnValue()

@SchedulerSupport(value = none)

fun delay(p0: Function<in T, out ObservableSource>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun delay(p0: ObservableSource, p1: Function<in T, out ObservableSource<V>>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun delay(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun delay(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun delay(p0: Long, p1: TimeUnit, p2: Boolean): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun delay(p0: Long, p1: TimeUnit, p2: Scheduler, p3: Boolean): Observable<T>

delaySubscription

@CheckReturnValue()

@SchedulerSupport(value = none)

fun delaySubscription(p0: ObservableSource): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun delaySubscription(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun delaySubscription(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

dematerialize

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <T2 : Any> dematerialize(): Observable<T2>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> dematerialize(p0: Function<in T, Notification<R>>): Observable<R>

distinct

@CheckReturnValue()

@SchedulerSupport(value = none)

fun distinct(): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any> distinct(p0: Function<in T, K>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any> distinct(p0: Function<in T, K>, p1: Callable<out MutableCollection<in K>>): Observable<T>

distinctUntilChanged

@CheckReturnValue()

@SchedulerSupport(value = none)

fun distinctUntilChanged(): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun distinctUntilChanged(p0: BiPredicate<in T, in T>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any> distinctUntilChanged(p0: Function<in T, K>): Observable<T>

doAfterNext

@CheckReturnValue()

@SchedulerSupport(value = none)

fun doAfterNext(p0: Consumer<in T>): Observable<T>

doAfterTerminate

@CheckReturnValue()

@SchedulerSupport(value = none)

fun doAfterTerminate(p0: Action): Observable<T>

doFinally

@CheckReturnValue()

@SchedulerSupport(value = none)

fun doFinally(p0: Action): Observable<T>

doOnComplete

@CheckReturnValue()

@SchedulerSupport(value = none)

fun doOnComplete(p0: Action): Observable<T>

doOnDispose

@CheckReturnValue()

@SchedulerSupport(value = none)

fun doOnDispose(p0: Action): Observable<T>

doOnEach

@CheckReturnValue()

@SchedulerSupport(value = none)

fun doOnEach(p0: Observer<in T>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun doOnEach(p0: Consumer<in Notification<T>>): Observable<T>

doOnError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun doOnError(p0: Consumer<in Throwable>): Observable<T>

doOnLifecycle

@CheckReturnValue()

@SchedulerSupport(value = none)

fun doOnLifecycle(p0: Consumer<in Disposable>, p1: Action): Observable<T>

doOnNext

@CheckReturnValue()

@SchedulerSupport(value = none)

fun doOnNext(p0: Consumer<in T>): Observable<T>

doOnSubscribe

@CheckReturnValue()

@SchedulerSupport(value = none)

fun doOnSubscribe(p0: Consumer<in Disposable>): Observable<T>

doOnTerminate

@CheckReturnValue()

@SchedulerSupport(value = none)

fun doOnTerminate(p0: Action): Observable<T>

elementAt

@CheckReturnValue()

@SchedulerSupport(value = none)

fun elementAt(p0: Long): Maybe<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun elementAt(p0: Long, p1: T): Single<T>

elementAtOrError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun elementAtOrError(p0: Long): Single<T>

filter

@CheckReturnValue()

@SchedulerSupport(value = none)

fun filter(p0: Predicate<in T>): Observable<T>

first

@CheckReturnValue()

@SchedulerSupport(value = none)

fun first(p0: T): Single<T>

firstElement

@CheckReturnValue()

@SchedulerSupport(value = none)

fun firstElement(): Maybe<T>

firstOrError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun firstOrError(): Single<T>

flatMap

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> flatMap(p0: Function<in T, out ObservableSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun flatMap(p0: Function<in T, out ObservableSource<out U>>, p1: BiFunction<in T, in U, out R>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> flatMap(p0: Function<in T, out ObservableSource<out R>>, p1: Boolean): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> flatMap(p0: Function<in T, out ObservableSource<out R>>, p1: Int): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun flatMap(p0: Function<in T, out ObservableSource<out U>>, p1: BiFunction<in T, in U, out R>, p2: Boolean): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun flatMap(p0: Function<in T, out ObservableSource<out U>>, p1: BiFunction<in T, in U, out R>, p2: Int): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> flatMap(p0: Function<in T, out ObservableSource<out R>>, p1: Function<in Throwable, out ObservableSource<out R>>, p2: Callable<out ObservableSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> flatMap(p0: Function<in T, out ObservableSource<out R>>, p1: Boolean, p2: Int): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun flatMap(p0: Function<in T, out ObservableSource<out U>>, p1: BiFunction<in T, in U, out R>, p2: Boolean, p3: Int): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> flatMap(p0: Function<in T, out ObservableSource<out R>>, p1: Function<Throwable, out ObservableSource<out R>>, p2: Callable<out ObservableSource<out R>>, p3: Int): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> flatMap(p0: Function<in T, out ObservableSource<out R>>, p1: Boolean, p2: Int, p3: Int): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun flatMap(p0: Function<in T, out ObservableSource<out U>>, p1: BiFunction<in T, in U, out R>, p2: Boolean, p3: Int, p4: Int): Observable<R>

flatMapCompletable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun flatMapCompletable(p0: Function<in T, out CompletableSource>): Completable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun flatMapCompletable(p0: Function<in T, out CompletableSource>, p1: Boolean): Completable

flatMapIterable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun flatMapIterable(p0: Function<in T, out MutableIterable>): Observable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun flatMapIterable(p0: Function<in T, out MutableIterable>, p1: BiFunction<in T, in U, out V>): Observable<V>

flatMapMaybe

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> flatMapMaybe(p0: Function<in T, out MaybeSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> flatMapMaybe(p0: Function<in T, out MaybeSource<out R>>, p1: Boolean): Observable<R>

flatMapSingle

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> flatMapSingle(p0: Function<in T, out SingleSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> flatMapSingle(p0: Function<in T, out SingleSource<out R>>, p1: Boolean): Observable<R>

forEach

@CheckReturnValue()

@SchedulerSupport(value = none)

fun forEach(p0: Consumer<in T>): Disposable

forEachWhile

@CheckReturnValue()

@SchedulerSupport(value = none)

fun forEachWhile(p0: Predicate<in T>): Disposable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun forEachWhile(p0: Predicate<in T>, p1: Consumer<in Throwable>): Disposable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun forEachWhile(p0: Predicate<in T>, p1: Consumer<in Throwable>, p2: Action): Disposable

groupBy

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any> groupBy(p0: Function<in T, out K>): Observable<GroupedObservable<K, T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any, V : Any> groupBy(p0: Function<in T, out K>, p1: Function<in T, out V>): Observable<GroupedObservable<K, V>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any> groupBy(p0: Function<in T, out K>, p1: Boolean): Observable<GroupedObservable<K, T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any, V : Any> groupBy(p0: Function<in T, out K>, p1: Function<in T, out V>, p2: Boolean): Observable<GroupedObservable<K, V>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any, V : Any> groupBy(p0: Function<in T, out K>, p1: Function<in T, out V>, p2: Boolean, p3: Int): Observable<GroupedObservable<K, V>>

groupJoin

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <TRight : Any, TLeftEnd : Any, TRightEnd : Any, R : Any> groupJoin(p0: ObservableSource<out TRight>, p1: Function<in T, out ObservableSource<TLeftEnd>>, p2: Function<in TRight, out ObservableSource<TRightEnd>>, p3: BiFunction<in T, in Observable<TRight>, out R>): Observable<R>

hide

@CheckReturnValue()

@SchedulerSupport(value = none)

fun hide(): Observable<T>

ignoreElements

@CheckReturnValue()

@SchedulerSupport(value = none)

fun ignoreElements(): Completable

isEmpty

@CheckReturnValue()

@SchedulerSupport(value = none)

fun isEmpty(): Single<Boolean>

join

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <TRight : Any, TLeftEnd : Any, TRightEnd : Any, R : Any> join(p0: ObservableSource<out TRight>, p1: Function<in T, out ObservableSource<TLeftEnd>>, p2: Function<in TRight, out ObservableSource<TRightEnd>>, p3: BiFunction<in T, in TRight, out R>): Observable<R>

last

@CheckReturnValue()

@SchedulerSupport(value = none)

fun last(p0: T): Single<T>

lastElement

@CheckReturnValue()

@SchedulerSupport(value = none)

fun lastElement(): Maybe<T>

lastOrError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun lastOrError(): Single<T>

lift

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> lift(p0: ObservableOperator<out R, in T>): Observable<R>

map

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> map(p0: Function<in T, out R>): Observable<R>

materialize

@CheckReturnValue()

@SchedulerSupport(value = none)

fun materialize(): Observable<Notification<T>>

mergeWith

@CheckReturnValue()

@SchedulerSupport(value = none)

fun mergeWith(@NonNull() p0: CompletableSource): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun mergeWith(@NonNull() p0: MaybeSource<out T>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun mergeWith(p0: ObservableSource<out T>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun mergeWith(@NonNull() p0: SingleSource<out T>): Observable<T>

observeOn

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun observeOn(p0: Scheduler): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun observeOn(p0: Scheduler, p1: Boolean): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun observeOn(p0: Scheduler, p1: Boolean, p2: Int): Observable<T>

ofType

@CheckReturnValue()

@SchedulerSupport(value = none)

fun ofType(p0: Class): Observable

onErrorResumeNext

@CheckReturnValue()

@SchedulerSupport(value = none)

fun onErrorResumeNext(p0: ObservableSource<out T>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun onErrorResumeNext(p0: Function<in Throwable, out ObservableSource<out T>>): Observable<T>

onErrorReturn

@CheckReturnValue()

@SchedulerSupport(value = none)

fun onErrorReturn(p0: Function<in Throwable, out T>): Observable<T>

onErrorReturnItem

@CheckReturnValue()

@SchedulerSupport(value = none)

fun onErrorReturnItem(p0: T): Observable<T>

onExceptionResumeNext

@CheckReturnValue()

@SchedulerSupport(value = none)

fun onExceptionResumeNext(p0: ObservableSource<out T>): Observable<T>

onTerminateDetach

@CheckReturnValue()

@SchedulerSupport(value = none)

fun onTerminateDetach(): Observable<T>

publish

@CheckReturnValue()

@SchedulerSupport(value = none)

fun publish(): ConnectableObservable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> publish(p0: Function<in Observable<T>, out ObservableSource<R>>): Observable<R>

reduce

@CheckReturnValue()

@SchedulerSupport(value = none)

fun reduce(p0: BiFunction<T, T, T>): Maybe<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> reduce(p0: R, p1: BiFunction<R, in T, R>): Single<R>

reduceWith

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> reduceWith(p0: Callable<R>, p1: BiFunction<R, in T, R>): Single<R>

repeat

@CheckReturnValue()

@SchedulerSupport(value = none)

fun repeat(): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun repeat(p0: Long): Observable<T>

repeatUntil

@CheckReturnValue()

@SchedulerSupport(value = none)

fun repeatUntil(p0: BooleanSupplier): Observable<T>

repeatWhen

@CheckReturnValue()

@SchedulerSupport(value = none)

fun repeatWhen(p0: Function<in Observable<Any>, out ObservableSource<*>>): Observable<T>

replay

@CheckReturnValue()

@SchedulerSupport(value = none)

fun replay(): ConnectableObservable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun replay(p0: Scheduler): ConnectableObservable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> replay(p0: Function<in Observable<T>, out ObservableSource<R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun replay(p0: Int): ConnectableObservable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun <R : Any> replay(p0: Function<in Observable<T>, out ObservableSource<R>>, p1: Scheduler): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> replay(p0: Function<in Observable<T>, out ObservableSource<R>>, p1: Int): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun replay(p0: Int, p1: Scheduler): ConnectableObservable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun replay(p0: Long, p1: TimeUnit): ConnectableObservable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun <R : Any> replay(p0: Function<in Observable<T>, out ObservableSource<R>>, p1: Int, p2: Scheduler): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun <R : Any> replay(p0: Function<in Observable<T>, out ObservableSource<R>>, p1: Long, p2: TimeUnit): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun replay(p0: Int, p1: Long, p2: TimeUnit): ConnectableObservable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun replay(p0: Long, p1: TimeUnit, p2: Scheduler): ConnectableObservable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun <R : Any> replay(p0: Function<in Observable<T>, out ObservableSource<R>>, p1: Int, p2: Long, p3: TimeUnit): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun <R : Any> replay(p0: Function<in Observable<T>, out ObservableSource<R>>, p1: Long, p2: TimeUnit, p3: Scheduler): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun replay(p0: Int, p1: Long, p2: TimeUnit, p3: Scheduler): ConnectableObservable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun <R : Any> replay(p0: Function<in Observable<T>, out ObservableSource<R>>, p1: Int, p2: Long, p3: TimeUnit, p4: Scheduler): Observable<R>

retry

@CheckReturnValue()

@SchedulerSupport(value = none)

fun retry(): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun retry(p0: BiPredicate<in Int, in Throwable>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun retry(p0: Predicate<in Throwable>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun retry(p0: Long): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun retry(p0: Long, p1: Predicate<in Throwable>): Observable<T>

retryUntil

@CheckReturnValue()

@SchedulerSupport(value = none)

fun retryUntil(p0: BooleanSupplier): Observable<T>

retryWhen

@CheckReturnValue()

@SchedulerSupport(value = none)

fun retryWhen(p0: Function<in Observable<Throwable>, out ObservableSource<*>>): Observable<T>

safeSubscribe

@SchedulerSupport(value = none)

fun safeSubscribe(p0: Observer<in T>)

sample

@CheckReturnValue()

@SchedulerSupport(value = none)

fun sample(p0: ObservableSource): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun sample(p0: ObservableSource, p1: Boolean): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun sample(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun sample(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun sample(p0: Long, p1: TimeUnit, p2: Boolean): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun sample(p0: Long, p1: TimeUnit, p2: Scheduler, p3: Boolean): Observable<T>

scan

@CheckReturnValue()

@SchedulerSupport(value = none)

fun scan(p0: BiFunction<T, T, T>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> scan(p0: R, p1: BiFunction<R, in T, R>): Observable<R>

scanWith

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> scanWith(p0: Callable<R>, p1: BiFunction<R, in T, R>): Observable<R>

serialize

@CheckReturnValue()

@SchedulerSupport(value = none)

fun serialize(): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun share(): Observable<T>

single

@CheckReturnValue()

@SchedulerSupport(value = none)

fun single(p0: T): Single<T>

singleElement

@CheckReturnValue()

@SchedulerSupport(value = none)

fun singleElement(): Maybe<T>

singleOrError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun singleOrError(): Single<T>

skip

@CheckReturnValue()

@SchedulerSupport(value = none)

fun skip(p0: Long): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun skip(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun skip(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

skipLast

@CheckReturnValue()

@SchedulerSupport(value = none)

fun skipLast(p0: Int): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:trampoline)

fun skipLast(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun skipLast(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:trampoline)

fun skipLast(p0: Long, p1: TimeUnit, p2: Boolean): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun skipLast(p0: Long, p1: TimeUnit, p2: Scheduler, p3: Boolean): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun skipLast(p0: Long, p1: TimeUnit, p2: Scheduler, p3: Boolean, p4: Int): Observable<T>

skipUntil

@CheckReturnValue()

@SchedulerSupport(value = none)

fun skipUntil(p0: ObservableSource): Observable<T>

skipWhile

@CheckReturnValue()

@SchedulerSupport(value = none)

fun skipWhile(p0: Predicate<in T>): Observable<T>

sorted

@CheckReturnValue()

@SchedulerSupport(value = none)

fun sorted(): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun sorted(p0: Comparator<in T>): Observable<T>

startWith

@CheckReturnValue()

@SchedulerSupport(value = none)

fun startWith(p0: T): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun startWith(p0: ObservableSource<out T>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun startWith(p0: MutableIterable<T>): Observable<T>

startWithArray

@CheckReturnValue()

@SchedulerSupport(value = none)

fun startWithArray(vararg p0: T): Observable<T>

@SchedulerSupport(value = none)

fun subscribe(): Disposable

@SchedulerSupport(value = none)

override fun subscribe(p0: Observer<in T>)

@CheckReturnValue()

@SchedulerSupport(value = none)

fun subscribe(p0: Consumer<in T>): Disposable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun subscribe(p0: Consumer<in T>, p1: Consumer<in Throwable>): Disposable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun subscribe(p0: Consumer<in T>, p1: Consumer<in Throwable>, p2: Action): Disposable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun subscribe(p0: Consumer<in T>, p1: Consumer<in Throwable>, p2: Action, p3: Consumer<in Disposable>): Disposable

subscribeActual

abstract fun subscribeActual(p0: Observer<in T>)

subscribeOn

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun subscribeOn(p0: Scheduler): Observable<T>

subscribeWith

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <E : Observer<in T>> subscribeWith(p0: E): E

switchIfEmpty

@CheckReturnValue()

@SchedulerSupport(value = none)

fun switchIfEmpty(p0: ObservableSource<out T>): Observable<T>

switchMap

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> switchMap(p0: Function<in T, out ObservableSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> switchMap(p0: Function<in T, out ObservableSource<out R>>, p1: Int): Observable<R>

switchMapCompletable

@CheckReturnValue()

@SchedulerSupport(value = none)

fun switchMapCompletable(@NonNull() p0: Function<in T, out CompletableSource>): Completable

switchMapCompletableDelayError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun switchMapCompletableDelayError(@NonNull() p0: Function<in T, out CompletableSource>): Completable

switchMapDelayError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> switchMapDelayError(p0: Function<in T, out ObservableSource<out R>>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> switchMapDelayError(p0: Function<in T, out ObservableSource<out R>>, p1: Int): Observable<R>

switchMapMaybe

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> switchMapMaybe(@NonNull() p0: Function<in T, out MaybeSource<out R>>): Observable<R>

switchMapMaybeDelayError

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> switchMapMaybeDelayError(@NonNull() p0: Function<in T, out MaybeSource<out R>>): Observable<R>

switchMapSingle

@CheckReturnValue()

@SchedulerSupport(value = none)

@NonNull()

fun <R : Any> switchMapSingle(@NonNull() p0: Function<in T, out SingleSource<out R>>): Observable<R>

switchMapSingleDelayError

@CheckReturnValue()

@SchedulerSupport(value = none)

@NonNull()

fun <R : Any> switchMapSingleDelayError(@NonNull() p0: Function<in T, out SingleSource<out R>>): Observable<R>

take

@CheckReturnValue()

@SchedulerSupport(value = none)

fun take(p0: Long): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun take(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun take(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

takeLast

@CheckReturnValue()

@SchedulerSupport(value = none)

fun takeLast(p0: Int): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:trampoline)

fun takeLast(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun takeLast(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:trampoline)

fun takeLast(p0: Long, p1: TimeUnit, p2: Boolean): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:trampoline)

fun takeLast(p0: Long, p1: Long, p2: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun takeLast(p0: Long, p1: TimeUnit, p2: Scheduler, p3: Boolean): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun takeLast(p0: Long, p1: Long, p2: TimeUnit, p3: Scheduler): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun takeLast(p0: Long, p1: TimeUnit, p2: Scheduler, p3: Boolean, p4: Int): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun takeLast(p0: Long, p1: Long, p2: TimeUnit, p3: Scheduler, p4: Boolean, p5: Int): Observable<T>

takeUntil

@CheckReturnValue()

@SchedulerSupport(value = none)

fun takeUntil(p0: ObservableSource): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun takeUntil(p0: Predicate<in T>): Observable<T>

takeWhile

@CheckReturnValue()

@SchedulerSupport(value = none)

fun takeWhile(p0: Predicate<in T>): Observable<T>

test

@CheckReturnValue()

@SchedulerSupport(value = none)

fun test(): TestObserver<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun test(p0: Boolean): TestObserver<T>

throttleFirst

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun throttleFirst(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun throttleFirst(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

throttleLast

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun throttleLast(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun throttleLast(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

throttleLatest

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun throttleLatest(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun throttleLatest(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun throttleLatest(p0: Long, p1: TimeUnit, p2: Boolean): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun throttleLatest(p0: Long, p1: TimeUnit, p2: Scheduler, p3: Boolean): Observable<T>

throttleWithTimeout

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun throttleWithTimeout(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun throttleWithTimeout(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

timeInterval

@CheckReturnValue()

@SchedulerSupport(value = none)

fun timeInterval(): Observable<Timed<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun timeInterval(p0: Scheduler): Observable<Timed<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun timeInterval(p0: TimeUnit): Observable<Timed<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun timeInterval(p0: TimeUnit, p1: Scheduler): Observable<Timed<T>>

timeout

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <V : Any> timeout(p0: Function<in T, out ObservableSource<V>>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun timeout(p0: ObservableSource, p1: Function<in T, out ObservableSource<V>>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <V : Any> timeout(p0: Function<in T, out ObservableSource<V>>, p1: ObservableSource<out T>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun timeout(p0: Long, p1: TimeUnit): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun timeout(p0: ObservableSource, p1: Function<in T, out ObservableSource<V>>, p2: ObservableSource<out T>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun timeout(p0: Long, p1: TimeUnit, p2: ObservableSource<out T>): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun timeout(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<T>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun timeout(p0: Long, p1: TimeUnit, p2: Scheduler, p3: ObservableSource<out T>): Observable<T>

timestamp

@CheckReturnValue()

@SchedulerSupport(value = none)

fun timestamp(): Observable<Timed<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun timestamp(p0: Scheduler): Observable<Timed<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun timestamp(p0: TimeUnit): Observable<Timed<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun timestamp(p0: TimeUnit, p1: Scheduler): Observable<Timed<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> to(p0: Function<in Observable<T>, R>): R

toFlowable

@BackpressureSupport(value = BackpressureKind.SPECIAL)

@CheckReturnValue()

@SchedulerSupport(value = none)

fun toFlowable(p0: BackpressureStrategy): Flowable<T>

toFuture

@CheckReturnValue()

@SchedulerSupport(value = none)

fun toFuture(): Future<T>

toList

@CheckReturnValue()

@SchedulerSupport(value = none)

fun toList(): Single<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun > toList(p0: Callable): Single

@CheckReturnValue()

@SchedulerSupport(value = none)

fun toList(p0: Int): Single<MutableList<T>>

toMap

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any> toMap(p0: Function<in T, out K>): Single<MutableMap<K, T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any, V : Any> toMap(p0: Function<in T, out K>, p1: Function<in T, out V>): Single<MutableMap<K, V>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any, V : Any> toMap(p0: Function<in T, out K>, p1: Function<in T, out V>, p2: Callable<out MutableMap<K, V>>): Single<MutableMap<K, V>>

toMultimap

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any> toMultimap(p0: Function<in T, out K>): Single<MutableMap<K, MutableCollection<T>>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any, V : Any> toMultimap(p0: Function<in T, out K>, p1: Function<in T, out V>): Single<MutableMap<K, MutableCollection<V>>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any, V : Any> toMultimap(p0: Function<in T, out K>, p1: Function<in T, out V>, p2: Callable<MutableMap<K, MutableCollection<V>>>): Single<MutableMap<K, MutableCollection<V>>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <K : Any, V : Any> toMultimap(p0: Function<in T, out K>, p1: Function<in T, out V>, p2: Callable<out MutableMap<K, MutableCollection<V>>>, p3: Function<in K, out MutableCollection<in V>>): Single<MutableMap<K, MutableCollection<V>>>

toSortedList

@CheckReturnValue()

@SchedulerSupport(value = none)

fun toSortedList(): Single<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun toSortedList(p0: Comparator<in T>): Single<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun toSortedList(p0: Int): Single<MutableList<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun toSortedList(p0: Comparator<in T>, p1: Int): Single<MutableList<T>>

unsubscribeOn

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun unsubscribeOn(p0: Scheduler): Observable<T>

window

@CheckReturnValue()

@SchedulerSupport(value = none)

fun window(p0: ObservableSource): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun window(p0: Callable<out ObservableSource>): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun window(p0: Long): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun window(p0: ObservableSource, p1: Function<in U, out ObservableSource<V>>): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun window(p0: ObservableSource, p1: Int): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun window(p0: Callable<out ObservableSource>, p1: Int): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun window(p0: Long, p1: TimeUnit): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun window(p0: Long, p1: Long): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun window(p0: ObservableSource, p1: Function<in U, out ObservableSource<V>>, p2: Int): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun window(p0: Long, p1: TimeUnit, p2: Scheduler): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun window(p0: Long, p1: TimeUnit, p2: Long): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun window(p0: Long, p1: Long, p2: TimeUnit): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun window(p0: Long, p1: Long, p2: Int): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun window(p0: Long, p1: TimeUnit, p2: Scheduler, p3: Long): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = io.reactivex:computation)

fun window(p0: Long, p1: TimeUnit, p2: Long, p3: Boolean): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun window(p0: Long, p1: Long, p2: TimeUnit, p3: Scheduler): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun window(p0: Long, p1: TimeUnit, p2: Scheduler, p3: Long, p4: Boolean): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun window(p0: Long, p1: Long, p2: TimeUnit, p3: Scheduler, p4: Int): Observable<Observable<T>>

@CheckReturnValue()

@SchedulerSupport(value = custom)

fun window(p0: Long, p1: TimeUnit, p2: Scheduler, p3: Long, p4: Boolean, p5: Int): Observable<Observable<T>>

withLatestFrom

@CheckReturnValue()

@SchedulerSupport(value = none)

fun withLatestFrom(p0: ObservableSource<out U>, p1: BiFunction<in T, in U, out R>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> withLatestFrom(p0: Array<ObservableSource<*>>, p1: Function<in Array<Any>, R>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <R : Any> withLatestFrom(p0: MutableIterable<ObservableSource<*>>, p1: Function<in Array<Any>, R>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <T1 : Any, T2 : Any, R : Any> withLatestFrom(p0: ObservableSource<T1>, p1: ObservableSource<T2>, p2: Function3<in T, in T1, in T2, R>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <T1 : Any, T2 : Any, T3 : Any, R : Any> withLatestFrom(p0: ObservableSource<T1>, p1: ObservableSource<T2>, p2: ObservableSource<T3>, p3: Function4<in T, in T1, in T2, in T3, R>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun <T1 : Any, T2 : Any, T3 : Any, T4 : Any, R : Any> withLatestFrom(p0: ObservableSource<T1>, p1: ObservableSource<T2>, p2: ObservableSource<T3>, p3: ObservableSource<T4>, p4: Function5<in T, in T1, in T2, in T3, in T4, R>): Observable<R>

zipWith

@CheckReturnValue()

@SchedulerSupport(value = none)

fun zipWith(p0: ObservableSource<out U>, p1: BiFunction<in T, in U, out R>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun zipWith(p0: MutableIterable, p1: BiFunction<in T, in U, out R>): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun zipWith(p0: ObservableSource<out U>, p1: BiFunction<in T, in U, out R>, p2: Boolean): Observable<R>

@CheckReturnValue()

@SchedulerSupport(value = none)

fun zipWith(p0: ObservableSource<out U>, p1: BiFunction<in T, in U, out R>, p2: Boolean, p3: Int): Observable<R>

Inheritors

ZTSignalBluetoothStateChange