Codestin Search App

java.lang.Object
- io.reactivex.rxjava3.core.Completable

All Implemented Interfaces:

CompletableSource

Direct Known Subclasses:

CompletableSubject
```
public abstract class Completable
extends Object
implements CompletableSource
```
The Completable class represents a deferred computation without any value but only indication for completion or exception.
Completable behaves similarly to Observable except that it can only emit either a completion or error signal (there is no onNext or onSuccess as with the other reactive types).
The Completable class implements the CompletableSource base interface and the default consumer type it interacts with is the CompletableObserver via the subscribe(CompletableObserver) method. The Completable operates with the following sequential protocol:
```
     onSubscribe (onError | onComplete)?
 
```
Note that as with the Observable protocol, onError and onComplete are mutually exclusive events.
Like Observable, a running Completable can be stopped through the Disposable instance provided to consumers through CompletableObserver.onSubscribe(io.reactivex.rxjava3.disposables.Disposable).
Like an Observable, a Completable is lazy, can be either "hot" or "cold", synchronous or asynchronous. Completable instances returned by the methods of this class are cold and there is a standard hot implementation in the form of a subject: CompletableSubject.
The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:

See Flowable or Observable for the implementation of the Reactive Pattern for a stream or vector of values.
Example:
```
 Disposable d = Completable.complete()
    .delay(10, TimeUnit.SECONDS, Schedulers.io())
    .subscribeWith(new DisposableCompletableObserver() {
        @Override
        public void onStart() {
            System.out.println("Started");
        }

        @Override
        public void onError(Throwable error) {
            error.printStackTrace();
        }

        @Override
        public void onComplete() {
            System.out.println("Done!");
        }
    });
 
 Thread.sleep(5000);
 
 d.dispose();
 
```
Note that by design, subscriptions via subscribe(CompletableObserver) can't be disposed from the outside (hence the void return of the subscribe(CompletableObserver) method) and it is the responsibility of the implementor of the CompletableObserver to allow this to happen. RxJava supports such usage with the standard DisposableCompletableObserver instance. For convenience, the subscribeWith(CompletableObserver) method is provided as well to allow working with a CompletableObserver (or subclass) instance to be applied with in a fluent manner (such as in the example above).
See Also:

DisposableCompletableObserver

Constructor Summary

Constructors
Constructor and Description

Completable()

Constructors
Constructor and Description
`Completable()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`static @NonNull Completable`	`amb(@NonNull Iterable<? extends CompletableSource> sources)` Returns a `Completable` which terminates as soon as one of the source `Completable`s in the `Iterable` sequence terminates (normally or with an error) and disposes all other `Completable`s.
`static @NonNull Completable`	`ambArray(CompletableSource... sources)` Returns a `Completable` which terminates as soon as one of the source `Completable`s terminates (normally or with an error) and disposes all other `Completable`s.
`@NonNull Completable`	`ambWith(@NonNull CompletableSource other)` Returns a `Completable` that emits the a terminated event of either this `Completable` or the other `CompletableSource`, whichever fires first.
`@NonNull Completable`	`andThen(@NonNull CompletableSource next)` Returns a `Completable` that first runs this `Completable` and then the other `CompletableSource`.
`<T> @NonNull Maybe<T>`	`andThen(@NonNull MaybeSource<T> next)` Returns a `Maybe` which will subscribe to this `Completable` and once that is completed then will subscribe to the `next` `MaybeSource`.
`<T> @NonNull Observable<T>`	`andThen(@NonNull ObservableSource<T> next)` Returns an `Observable` which will subscribe to this `Completable` and once that is completed then will subscribe to the `next` `ObservableSource`.
`<T> @NonNull Flowable<T>`	`andThen(@NonNull Publisher<T> next)` Returns a `Flowable` which will subscribe to this `Completable` and once that is completed then will subscribe to the `next` `Publisher`.
`<T> @NonNull Single<T>`	`andThen(@NonNull SingleSource<T> next)` Returns a `Single` which will subscribe to this `Completable` and once that is completed then will subscribe to the `next` `SingleSource`.
`void`	`blockingAwait()` Subscribes to and awaits the termination of this `Completable` instance in a blocking manner and rethrows any exception emitted.
`boolean`	`blockingAwait(long timeout, @NonNull TimeUnit unit)` Subscribes to and awaits the termination of this `Completable` instance in a blocking manner with a specific timeout and rethrows any exception emitted within the timeout window.
`void`	`blockingSubscribe()` Subscribes to the current `Completable` and blocks the current thread until it terminates.
`void`	`blockingSubscribe(@NonNull Action onComplete)` Subscribes to the current `Completable` and calls given `onComplete` callback on the current thread when it completes normally.
`void`	`blockingSubscribe(@NonNull Action onComplete, @NonNull Consumer<? super Throwable> onError)` Subscribes to the current `Completable` and calls the appropriate callback on the current thread when it terminates.
`void`	`blockingSubscribe(@NonNull CompletableObserver observer)` Subscribes to the current `Completable` and calls the appropriate `CompletableObserver` method on the current thread.
`@NonNull Completable`	`cache()` Subscribes to this `Completable` only once, when the first `CompletableObserver` subscribes to the result `Completable`, caches its terminal event and relays/replays it to observers.
`static @NonNull Completable`	`complete()` Returns a `Completable` instance that completes immediately when subscribed to.
`@NonNull Completable`	`compose(@NonNull CompletableTransformer transformer)` Calls the given transformer function with this instance and returns the function's resulting `CompletableSource` wrapped with `wrap(CompletableSource)`.
`static @NonNull Completable`	`concat(@NonNull Iterable<? extends CompletableSource> sources)` Returns a `Completable` which completes only when all sources complete, one after another.
`static @NonNull Completable`	`concat(@NonNull Publisher<? extends CompletableSource> sources)` Returns a `Completable` which completes only when all sources complete, one after another.
`static @NonNull Completable`	`concat(@NonNull Publisher<? extends CompletableSource> sources, int prefetch)` Returns a `Completable` which completes only when all sources complete, one after another.
`static @NonNull Completable`	`concatArray(CompletableSource... sources)` Returns a `Completable` which completes only when all sources complete, one after another.
`static @NonNull Completable`	`concatArrayDelayError(CompletableSource... sources)` Returns a `Completable` which completes only when all sources complete, one after another.
`static @NonNull Completable`	`concatDelayError(@NonNull Iterable<? extends CompletableSource> sources)` Returns a `Completable` which completes only when all sources complete, one after another.
`static @NonNull Completable`	`concatDelayError(@NonNull Publisher<? extends CompletableSource> sources)` Returns a `Completable` which completes only when all sources complete, one after another.
`static @NonNull Completable`	`concatDelayError(@NonNull Publisher<? extends CompletableSource> sources, int prefetch)` Returns a `Completable` which completes only when all sources complete, one after another.
`@NonNull Completable`	`concatWith(@NonNull CompletableSource other)` Concatenates this `Completable` with another `CompletableSource`.
`static @NonNull Completable`	`create(@NonNull CompletableOnSubscribe source)` Provides an API (via a cold `Completable`) that bridges the reactive world with the callback-style world.
`static @NonNull Completable`	`defer(@NonNull Supplier<? extends CompletableSource> supplier)` Defers the subscription to a `Completable` instance returned by a supplier.
`@NonNull Completable`	`delay(long time, @NonNull TimeUnit unit)` Returns a `Completable` which delays the emission of the completion event by the given time.
`@NonNull Completable`	`delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)` Returns a `Completable` which delays the emission of the completion event by the given time while running on the specified `Scheduler`.
`@NonNull Completable`	`delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)` Returns a `Completable` which delays the emission of the completion event, and optionally the error as well, by the given time while running on the specified `Scheduler`.
`@NonNull Completable`	`delaySubscription(long time, @NonNull TimeUnit unit)` Returns a `Completable` that delays the subscription to the upstream by a given amount of time.
`@NonNull Completable`	`delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)` Returns a `Completable` that delays the subscription to the upstream by a given amount of time, both waiting and subscribing on a given `Scheduler`.
`@NonNull Completable`	`doAfterTerminate(@NonNull Action onAfterTerminate)` Returns a `Completable` instance that calls the given `onAfterTerminate` `Action` after this `Completable` completes normally or with an exception.
`@NonNull Completable`	`doFinally(@NonNull Action onFinally)` Calls the specified `Action` after this `Completable` signals `onError` or `onComplete` or gets disposed by the downstream.
`@NonNull Completable`	`doOnComplete(@NonNull Action onComplete)` Returns a `Completable` which calls the given `onComplete` `Action` if this `Completable` completes.
`@NonNull Completable`	`doOnDispose(@NonNull Action onDispose)` Calls the shared `Action` if a `CompletableObserver` subscribed to the current `Completable` disposes the common `Disposable` it received via `onSubscribe`.
`@NonNull Completable`	`doOnError(@NonNull Consumer<? super Throwable> onError)` Returns a `Completable` which calls the given `onError` `Consumer` if this `Completable` emits an error.
`@NonNull Completable`	`doOnEvent(@NonNull Consumer<? super Throwable> onEvent)` Returns a `Completable` which calls the given `onEvent` `Consumer` with the `Throwable` for an `onError` or `null` for an `onComplete` signal from this `Completable` before delivering the signal to the downstream.
`@NonNull Completable`	`doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)` Calls the appropriate `onXXX` method (shared between all `CompletableObserver`s) for the lifecycle events of the sequence (subscription, disposal).
`@NonNull Completable`	`doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)` Returns a `Completable` instance that calls the given `onSubscribe` callback with the disposable that the downstream `CompletableObserver`s receive upon subscription.
`@NonNull Completable`	`doOnTerminate(@NonNull Action onTerminate)` Returns a `Completable` instance that calls the given `onTerminate` `Action` just before this `Completable` completes normally or with an exception.
`static @NonNull Completable`	`error(@NonNull Supplier<? extends Throwable> supplier)` Creates a `Completable` which calls the given error supplier for each subscriber and emits its returned `Throwable`.
`static @NonNull Completable`	`error(@NonNull Throwable throwable)` Creates a `Completable` instance that emits the given `Throwable` exception to subscribers.
`static @NonNull Completable`	`fromAction(@NonNull Action action)` Returns a `Completable` instance that runs the given `Action` for each `CompletableObserver` and emits either an exception or simply completes.
`static @NonNull Completable`	`fromCallable(@NonNull Callable<?> callable)` Returns a `Completable` which when subscribed, executes the `Callable` function, ignores its normal result and emits `onError` or `onComplete` only.
`static @NonNull Completable`	`fromCompletionStage(@NonNull CompletionStage<?> stage)` Signals completion (or error) when the `CompletionStage` terminates.
`static @NonNull Completable`	`fromFuture(@NonNull Future<?> future)` Returns a `Completable` instance that reacts to the termination of the given `Future` in a blocking fashion.
`static <T> @NonNull Completable`	`fromMaybe(@NonNull MaybeSource<T> maybe)` Returns a `Completable` instance that when subscribed to, subscribes to the `MaybeSource` instance and emits an `onComplete` event if the maybe emits `onSuccess`/`onComplete` or forwards any `onError` events.
`static <T> @NonNull Completable`	`fromObservable(@NonNull ObservableSource<T> observable)` Returns a `Completable` instance that subscribes to the given `ObservableSource`, ignores all values and emits only the terminal event.
`static <T> @NonNull Completable`	`fromPublisher(@NonNull Publisher<T> publisher)` Returns a `Completable` instance that subscribes to the given `Publisher`, ignores all values and emits only the terminal event.
`static @NonNull Completable`	`fromRunnable(@NonNull Runnable run)` Returns a `Completable` instance that runs the given `Runnable` for each `CompletableObserver` and emits either its unchecked exception or simply completes.
`static <T> @NonNull Completable`	`fromSingle(@NonNull SingleSource<T> single)` Returns a `Completable` instance that when subscribed to, subscribes to the `SingleSource` instance and emits a completion event if the single emits `onSuccess` or forwards any `onError` events.
`static @NonNull Completable`	`fromSupplier(@NonNull Supplier<?> supplier)` Returns a `Completable` which when subscribed, executes the `Supplier` function, ignores its normal result and emits `onError` or `onComplete` only.
`@NonNull Completable`	`hide()` Hides the identity of this `Completable` and its `Disposable`.
`@NonNull Completable`	`lift(@NonNull CompletableOperator onLift)` This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a `Completable` which, when subscribed to, invokes the `apply(CompletableObserver)` method of the provided `CompletableOperator` for each individual downstream `Completable` and allows the insertion of a custom operator by accessing the downstream's `CompletableObserver` during this subscription phase and providing a new `CompletableObserver`, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
`<T> @NonNull Single<Notification<T>>`	`materialize()` Maps the signal types of this `Completable` into a `Notification` of the same kind and emits it as a single success value to downstream.
`static @NonNull Completable`	`merge(@NonNull Iterable<? extends CompletableSource> sources)` Returns a `Completable` instance that subscribes to all sources at once and completes only when all source `CompletableSource`s complete or one of them emits an error.
`static @NonNull Completable`	`merge(@NonNull Publisher<? extends CompletableSource> sources)` Returns a `Completable` instance that subscribes to all sources at once and completes only when all source `CompletableSource`s complete or one of them emits an error.
`static @NonNull Completable`	`merge(@NonNull Publisher<? extends CompletableSource> sources, int maxConcurrency)` Returns a `Completable` instance that keeps subscriptions to a limited number of sources at once and completes only when all source `CompletableSource`s complete or one of them emits an error.
`static @NonNull Completable`	`mergeArray(CompletableSource... sources)` Returns a `Completable` instance that subscribes to all sources at once and completes only when all source `CompletableSource`s complete or one of them emits an error.
`static @NonNull Completable`	`mergeArrayDelayError(CompletableSource... sources)` Returns a `Completable` that subscribes to all `CompletableSource`s in the source array and delays any error emitted by any of the inner `CompletableSource`s until all of them terminate in a way or another.
`static @NonNull Completable`	`mergeDelayError(@NonNull Iterable<? extends CompletableSource> sources)` Returns a `Completable` that subscribes to all `CompletableSource`s in the source sequence and delays any error emitted by any of the inner `CompletableSource`s until all of them terminate in a way or another.
`static @NonNull Completable`	`mergeDelayError(@NonNull Publisher<? extends CompletableSource> sources)` Returns a `Completable` that subscribes to all `CompletableSource`s in the source sequence and delays any error emitted by either the sources `Publisher` or any of the inner `CompletableSource`s until all of them terminate in a way or another.
`static @NonNull Completable`	`mergeDelayError(@NonNull Publisher<? extends CompletableSource> sources, int maxConcurrency)` Returns a `Completable` that subscribes to a limited number of inner `CompletableSource`s at once in the source sequence and delays any error emitted by either the sources `Publisher` or any of the inner `CompletableSource`s until all of them terminate in a way or another.
`@NonNull Completable`	`mergeWith(@NonNull CompletableSource other)` Returns a `Completable` which subscribes to this and the other `CompletableSource` and completes when both of them complete or one emits an error.
`static @NonNull Completable`	`never()` Returns a `Completable` that never calls `onError` or `onComplete`.
`@NonNull Completable`	`observeOn(@NonNull Scheduler scheduler)` Returns a `Completable` which emits the terminal events from the thread of the specified `Scheduler`.
`@NonNull Completable`	`onErrorComplete()` Returns a `Completable` instance that if this `Completable` emits an error, it will emit an `onComplete` and swallow the upstream `Throwable`.
`@NonNull Completable`	`onErrorComplete(@NonNull Predicate<? super Throwable> predicate)` Returns a `Completable` instance that if this `Completable` emits an error and the `Predicate` returns `true`, it will emit an `onComplete` and swallow the `Throwable`.
`@NonNull Completable`	`onErrorResumeNext(@NonNull Function<? super Throwable,? extends CompletableSource> fallbackSupplier)` Returns a `Completable` instance that when encounters an error from this `Completable`, calls the specified `mapper` `Function` that returns a `CompletableSource` instance for it and resumes the execution with it.
`@NonNull Completable`	`onErrorResumeWith(@NonNull CompletableSource fallback)` Resumes the flow with the given `CompletableSource` when the current `Completable` fails instead of signaling the error via `onError`.
`<T> @NonNull Maybe<T>`	`onErrorReturn(@NonNull Function<? super Throwable,? extends T> itemSupplier)` Ends the flow with a success item returned by a function for the `Throwable` error signaled by the current `Completable` instead of signaling the error via `onError`.
`<T> @NonNull Maybe<T>`	`onErrorReturnItem(T item)` Ends the flow with the given success item when the current `Completable` fails instead of signaling the error via `onError`.
`@NonNull Completable`	`onTerminateDetach()` Nulls out references to the upstream producer and downstream `CompletableObserver` if the sequence is terminated or downstream calls `dispose()`.
`@NonNull Completable`	`repeat()` Returns a `Completable` that repeatedly subscribes to this `Completable` until disposed.
`@NonNull Completable`	`repeat(long times)` Returns a `Completable` that subscribes repeatedly at most the given number of times to this `Completable`.
`@NonNull Completable`	`repeatUntil(@NonNull BooleanSupplier stop)` Returns a `Completable` that repeatedly subscribes to this `Completable` so long as the given stop `BooleanSupplier` returns `false`.
`@NonNull Completable`	`repeatWhen(@NonNull Function<? super Flowable<Object>,? extends Publisher<?>> handler)` Returns a `Completable` instance that repeats when the `Publisher` returned by the handler `Function` emits an item or completes when this `Publisher` emits an `onComplete` event.
`@NonNull Completable`	`retry()` Returns a `Completable` that retries this `Completable` as long as it emits an `onError` event.
`@NonNull Completable`	`retry(@NonNull BiPredicate<? super Integer,? super Throwable> predicate)` Returns a `Completable` that retries this `Completable` in case of an error as long as the `predicate` returns `true`.
`@NonNull Completable`	`retry(long times)` Returns a `Completable` that when this `Completable` emits an error, retries at most the given number of times before giving up and emitting the last error.
`@NonNull Completable`	`retry(long times, @NonNull Predicate<? super Throwable> predicate)` Returns a `Completable` that when this `Completable` emits an error, retries at most times or until the predicate returns `false`, whichever happens first and emitting the last error.
`@NonNull Completable`	`retry(@NonNull Predicate<? super Throwable> predicate)` Returns a `Completable` that when this `Completable` emits an error, calls the given predicate with the latest `Throwable` to decide whether to resubscribe to the upstream or not.
`@NonNull Completable`	`retryUntil(@NonNull BooleanSupplier stop)` Retries until the given stop function returns `true`.
`@NonNull Completable`	`retryWhen(@NonNull Function<? super Flowable<Throwable>,? extends Publisher<?>> handler)` Returns a `Completable` which given a `Publisher` and when this `Completable` emits an error, delivers that error through a `Flowable` and the `Publisher` should signal a value indicating a retry in response or a terminal event indicating a termination.
`void`	`safeSubscribe(@NonNull CompletableObserver observer)` Wraps the given `CompletableObserver`, catches any `RuntimeException`s thrown by its `CompletableObserver.onSubscribe(Disposable)`, `CompletableObserver.onError(Throwable)` or `CompletableObserver.onComplete()` methods and routes those to the global error handler via `RxJavaPlugins.onError(Throwable)`.
`static @NonNull Single<Boolean>`	`sequenceEqual(@NonNull CompletableSource source1, @NonNull CompletableSource source2)` Compares two `CompletableSource`s and emits `true` via a `Single` if both complete.
`@NonNull Completable`	`startWith(@NonNull CompletableSource other)` Returns a `Completable` which first runs the other `CompletableSource` then the current `Completable` if the other completed normally.
`<T> @NonNull Flowable<T>`	`startWith(@NonNull MaybeSource<T> other)` Returns a `Flowable` which first runs the other `MaybeSource` then the current `Completable` if the other succeeded or completed normally.
`<T> @NonNull Observable<T>`	`startWith(@NonNull ObservableSource<T> other)` Returns an `Observable` which first delivers the events of the other `ObservableSource` then runs the current `Completable`.
`<T> @NonNull Flowable<T>`	`startWith(@NonNull Publisher<T> other)` Returns a `Flowable` which first delivers the events of the other `Publisher` then runs the current `Completable`.
`<T> @NonNull Flowable<T>`	`startWith(@NonNull SingleSource<T> other)` Returns a `Flowable` which first runs the other `SingleSource` then the current `Completable` if the other succeeded normally.
`@NonNull Disposable`	`subscribe()` Subscribes to this `Completable` and returns a `Disposable` which can be used to dispose the subscription.
`@NonNull Disposable`	`subscribe(@NonNull Action onComplete)` Subscribes to this `Completable` and calls the given `Action` when this `Completable` completes normally.
`@NonNull Disposable`	`subscribe(@NonNull Action onComplete, @NonNull Consumer<? super Throwable> onError)` Subscribes to this `Completable` and calls back either the `onError` or `onComplete` functions.
`@NonNull Disposable`	`subscribe(@NonNull Action onComplete, @NonNull Consumer<? super Throwable> onError, @NonNull DisposableContainer container)` Wraps the given onXXX callbacks into a `Disposable` `CompletableObserver`, adds it to the given `DisposableContainer` and ensures, that if the upstream terminates or this particular `Disposable` is disposed, the `CompletableObserver` is removed from the given composite.
`void`	`subscribe(@NonNull CompletableObserver observer)` Subscribes the given `CompletableObserver` to this `CompletableSource` instance.
`protected abstract void`	`subscribeActual(@NonNull CompletableObserver observer)` Implement this method to handle the incoming `CompletableObserver`s and perform the business logic in your operator.
`@NonNull Completable`	`subscribeOn(@NonNull Scheduler scheduler)` Returns a `Completable` which subscribes the downstream subscriber on the specified scheduler, making sure the subscription side-effects happen on that specific thread of the `Scheduler`.
`<E extends CompletableObserver> E`	`subscribeWith(E observer)` Subscribes a given `CompletableObserver` (subclass) to this `Completable` and returns the given `CompletableObserver` as is.
`static @NonNull Completable`	`switchOnNext(@NonNull Publisher<? extends CompletableSource> sources)` Switches between `CompletableSource`s emitted by the source `Publisher` whenever a new `CompletableSource` is emitted, disposing the previously running `CompletableSource`, exposing the setup as a `Completable` sequence.
`static @NonNull Completable`	`switchOnNextDelayError(@NonNull Publisher<? extends CompletableSource> sources)` Switches between `CompletableSource`s emitted by the source `Publisher` whenever a new `CompletableSource` is emitted, disposing the previously running `CompletableSource`, exposing the setup as a `Completable` sequence and delaying all errors from all of them until all terminate.
`@NonNull Completable`	`takeUntil(@NonNull CompletableSource other)` Terminates the downstream if this or the other `Completable` terminates (wins the termination race) while disposing the connection to the losing source.
`@NonNull TestObserver<Void>`	`test()` Creates a `TestObserver` and subscribes it to this `Completable`.
`@NonNull TestObserver<Void>`	`test(boolean dispose)` Creates a `TestObserver` optionally in cancelled state, then subscribes it to this `Completable`.
`@NonNull Completable`	`timeout(long timeout, @NonNull TimeUnit unit)` Returns a `Completabl`e that runs this `Completable` and emits a `TimeoutException` in case this `Completable` doesn't complete within the given time.
`@NonNull Completable`	`timeout(long timeout, @NonNull TimeUnit unit, @NonNull CompletableSource fallback)` Returns a `Completable` that runs this `Completable` and switches to the other `CompletableSource` in case this `Completable` doesn't complete within the given time.
`@NonNull Completable`	`timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)` Returns a `Completable` that runs this `Completable` and emits a `TimeoutException` in case this `Completable` doesn't complete within the given time while "waiting" on the specified `Scheduler`.
`@NonNull Completable`	`timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull CompletableSource fallback)` Returns a `Completable` that runs this `Completable` and switches to the other `CompletableSource` in case this `Completable` doesn't complete within the given time while "waiting" on the specified `Scheduler`.
`static @NonNull Completable`	`timer(long delay, @NonNull TimeUnit unit)` Returns a `Completable` instance that fires its `onComplete` event after the given delay elapsed.
`static @NonNull Completable`	`timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)` Returns a `Completable` instance that fires its `onComplete` event after the given delay elapsed by using the supplied `Scheduler`.
`<R> R`	`to(@NonNull CompletableConverter<? extends R> converter)` Calls the specified `CompletableConverter` function during assembly time and returns its resulting value.
`<T> @NonNull CompletionStage<T>`	`toCompletionStage(T defaultItem)` Signals the given default item when the upstream completes or signals the upstream error via a `CompletionStage`.
`<T> @NonNull Flowable<T>`	`toFlowable()` Returns a `Flowable` which when subscribed to subscribes to this `Completable` and relays the terminal events to the downstream `Subscriber`.
`@NonNull Future<Void>`	`toFuture()` Returns a `Future` representing the termination of the current `Completable` via a `null` value.
`<T> @NonNull Maybe<T>`	`toMaybe()` Converts this `Completable` into a `Maybe`.
`<T> @NonNull Observable<T>`	`toObservable()` Returns an `Observable` which when subscribed to subscribes to this `Completable` and relays the terminal events to the downstream `Observer`.
`<T> @NonNull Single<T>`	`toSingle(@NonNull Supplier<? extends T> completionValueSupplier)` Converts this `Completable` into a `Single` which when this `Completable` completes normally, calls the given `Supplier` and emits its returned value through `onSuccess`.
`<T> @NonNull Single<T>`	`toSingleDefault(T completionValue)` Converts this `Completable` into a `Single` which when this `Completable` completes normally, emits the given value through `onSuccess`.
`static @NonNull Completable`	`unsafeCreate(@NonNull CompletableSource onSubscribe)` Constructs a `Completable` instance by wrapping the given source callback without any safeguards; you should manage the lifecycle and response to downstream disposal.
`@NonNull Completable`	`unsubscribeOn(@NonNull Scheduler scheduler)` Returns a `Completable` which makes sure when an observer disposes the subscription, the `dispose()` method is called on the specified `Scheduler`.
`static <R> @NonNull Completable`	`using(@NonNull Supplier<R> resourceSupplier, @NonNull Function<? super R,? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super R> resourceCleanup)` Returns a `Completable` instance which manages a resource along with a custom `CompletableSource` instance while the subscription is active.
`static <R> @NonNull Completable`	`using(@NonNull Supplier<R> resourceSupplier, @NonNull Function<? super R,? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super R> resourceCleanup, boolean eager)` Returns a `Completable` instance which manages a resource along with a custom `CompletableSource` instance while the subscription is active and performs eager or lazy resource disposition.
`static @NonNull Completable`	`wrap(@NonNull CompletableSource source)` Wraps the given `CompletableSource` into a `Completable` if not already `Completable`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Completable
```
public Completable()
```
- Method Detail
  - ambArray
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @SafeVarargs
public static @NonNull Completable ambArray(@NonNull CompletableSource... sources)
```
    Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and disposes all other Completables.
    
    Scheduler:
    
    ambArray does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the array of source Completables. A subscription to each source will occur in the same order as in this array.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - amb
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable amb(@NonNull Iterable<? extends CompletableSource> sources)
```
    Returns a Completable which terminates as soon as one of the source Completables in the Iterable sequence terminates (normally or with an error) and disposes all other Completables.
    
    Scheduler:
    
    amb does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the Iterable of source Completables. A subscription to each source will occur in the same order as in this Iterable.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - complete
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable complete()
```
    Returns a Completable instance that completes immediately when subscribed to.
    
    Scheduler:
    
    complete does not operate by default on a particular Scheduler.
    
    Returns:
    
    the shared Completable instance
  - concatArray
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @SafeVarargs
public static @NonNull Completable concatArray(@NonNull CompletableSource... sources)
```
    Returns a Completable which completes only when all sources complete, one after another.
    
    Scheduler:
    
    concatArray does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sources to concatenate
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - concatArrayDelayError
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @SafeVarargs
public static @NonNull Completable concatArrayDelayError(@NonNull CompletableSource... sources)
```
    Returns a Completable which completes only when all sources complete, one after another.
    
    Scheduler:
    
    concatArrayDelayError does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sources to concatenate
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    Since:
    
    3.0.0
  - concat
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable concat(@NonNull Iterable<? extends CompletableSource> sources)
```
    Returns a Completable which completes only when all sources complete, one after another.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sources to concatenate
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - concat
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
 @NonNull
public static @NonNull Completable concat(@NonNull Publisher<? extends CompletableSource> sources)
```
    Returns a Completable which completes only when all sources complete, one after another.
    
    Backpressure:
    
    The returned Completable honors the backpressure of the downstream consumer and expects the other Publisher to honor it as well.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sources to concatenate
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - concat
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static @NonNull Completable concat(@NonNull Publisher<? extends CompletableSource> sources,
        int prefetch)
```
    Returns a Completable which completes only when all sources complete, one after another.
    
    Backpressure:
    
    The returned Completable honors the backpressure of the downstream consumer and expects the other Publisher to honor it as well.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sources to concatenate
    
    prefetch - the number of sources to prefetch from the sources
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    IllegalArgumentException - if prefetch is non-positive
  - concatDelayError
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable concatDelayError(@NonNull Iterable<? extends CompletableSource> sources)
```
    Returns a Completable which completes only when all sources complete, one after another.
    
    Scheduler:
    
    concatDelayError does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sources to concatenate
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    Since:
    
    3.0.0
  - concatDelayError
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
 @NonNull
public static @NonNull Completable concatDelayError(@NonNull Publisher<? extends CompletableSource> sources)
```
    Returns a Completable which completes only when all sources complete, one after another.
    
    Backpressure:
    
    The returned Completable honors the backpressure of the downstream consumer and expects the other Publisher to honor it as well.
    
    Scheduler:
    
    concatDelayError does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sources to concatenate
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    Since:
    
    3.0.0
  - concatDelayError
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static @NonNull Completable concatDelayError(@NonNull Publisher<? extends CompletableSource> sources,
        int prefetch)
```
    Returns a Completable which completes only when all sources complete, one after another.
    
    Backpressure:
    
    The returned Completable honors the backpressure of the downstream consumer and expects the other Publisher to honor it as well.
    
    Scheduler:
    
    concatDelayError does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sources to concatenate
    
    prefetch - the number of sources to prefetch from the sources
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    IllegalArgumentException - if prefetch is non-positive
    
    Since:
    
    3.0.0
  - create
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable create(@NonNull CompletableOnSubscribe source)
```
    Provides an API (via a cold Completable) that bridges the reactive world with the callback-style world.
    
    Example:
```
 Completable.create(emitter -> {
     Callback listener = new Callback() {
         @Override
         public void onEvent(Event e) {
             emitter.onComplete();
         }

         @Override
         public void onFailure(Exception e) {
             emitter.onError(e);
         }
     };

     AutoCloseable c = api.someMethod(listener);

     emitter.setCancellable(c::close);

 });
 
```
    Whenever a CompletableObserver subscribes to the returned Completable, the provided CompletableOnSubscribe callback is invoked with a fresh instance of a CompletableEmitter that will interact only with that specific CompletableObserver. If this CompletableObserver disposes the flow (making CompletableEmitter.isDisposed() return true), other observers subscribed to the same returned Completable are not affected.
    
    Scheduler:
    
    create does not operate by default on a particular Scheduler.
    Parameters:
    
    source - the emitter that is called when a CompletableObserver subscribes to the returned Completable
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if source is null
    
    See Also:
    
    CompletableOnSubscribe, Cancellable
  - sequenceEqual
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Single<Boolean> sequenceEqual(@NonNull CompletableSource source1,
        @NonNull CompletableSource source2)
```
    Compares two CompletableSources and emits true via a Single if both complete.
    
    Scheduler:
    
    sequenceEqual does not operate by default on a particular Scheduler.
    
    Parameters:
    
    source1 - the first CompletableSource instance
    
    source2 - the second CompletableSource instance
    
    Returns:
    
    the new Single instance
    
    Throws:
    
    NullPointerException - if source1 or source2 is null
    
    Since:
    
    3.0.0
  - unsafeCreate
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable unsafeCreate(@NonNull CompletableSource onSubscribe)
```
    Constructs a Completable instance by wrapping the given source callback without any safeguards; you should manage the lifecycle and response to downstream disposal.
    
    Scheduler:
    
    unsafeCreate does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onSubscribe - the callback which will receive the CompletableObserver instances when the Completable is subscribed to.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onSubscribe is null
    
    IllegalArgumentException - if source is a Completable
  - defer
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable defer(@NonNull Supplier<? extends CompletableSource> supplier)
```
    Defers the subscription to a Completable instance returned by a supplier.
    
    Scheduler:
    
    defer does not operate by default on a particular Scheduler.
    
    Parameters:
    
    supplier - the supplier that returns the Completable that will be subscribed to.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if supplier is null
  - error
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable error(@NonNull Supplier<? extends Throwable> supplier)
```
    Creates a Completable which calls the given error supplier for each subscriber and emits its returned Throwable.
    
    If the errorSupplier returns null, the downstream CompletableObservers will receive a NullPointerException.
    
    Scheduler:
    
    error does not operate by default on a particular Scheduler.
    
    Parameters:
    
    supplier - the error supplier, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if supplier is null
  - error
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable error(@NonNull Throwable throwable)
```
    Creates a Completable instance that emits the given Throwable exception to subscribers.
    
    Scheduler:
    
    error does not operate by default on a particular Scheduler.
    
    Parameters:
    
    throwable - the Throwable instance to emit, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if throwable is null
  - fromAction
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable fromAction(@NonNull Action action)
```
    Returns a Completable instance that runs the given Action for each CompletableObserver and emits either an exception or simply completes.
    
    Scheduler:
    
    fromAction does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If the Action throws an exception, the respective Throwable is delivered to the downstream via CompletableObserver.onError(Throwable), except when the downstream has disposed this Completable source. In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) as an UndeliverableException.
    
    Parameters:
    
    action - the Action to run for each subscribing CompletableObserver
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if action is null
  - fromCallable
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable fromCallable(@NonNull Callable<?> callable)
```
    Returns a Completable which when subscribed, executes the Callable function, ignores its normal result and emits onError or onComplete only.
    
    Scheduler:
    
    fromCallable does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If the Callable throws an exception, the respective Throwable is delivered to the downstream via CompletableObserver.onError(Throwable), except when the downstream has disposed this Completable source. In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) as an UndeliverableException.
    
    Parameters:
    
    callable - the Callable instance to execute for each subscribing CompletableObserver
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if callable is null
    
    See Also:
    
    defer(Supplier), fromSupplier(Supplier)
  - fromFuture
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable fromFuture(@NonNull Future<?> future)
```
    Returns a Completable instance that reacts to the termination of the given Future in a blocking fashion.
    
    Note that disposing the Completable won't cancel the Future. Use doOnDispose(Action) and call Future.cancel(boolean) in the Action.
    
    Scheduler:
    
    fromFuture does not operate by default on a particular Scheduler.
    
    Parameters:
    
    future - the Future to react to
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if future is null
    
    See Also:
    
    fromCompletionStage(CompletionStage)
  - fromMaybe
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Completable fromMaybe(@NonNull MaybeSource<T> maybe)
```
    Returns a Completable instance that when subscribed to, subscribes to the MaybeSource instance and emits an onComplete event if the maybe emits onSuccess/onComplete or forwards any onError events.
    
    Scheduler:
    
    fromMaybe does not operate by default on a particular Scheduler.
    
    History: 2.1.17 - beta
    
    Type Parameters:
    
    T - the value type of the MaybeSource element
    
    Parameters:
    
    maybe - the MaybeSource instance to subscribe to, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if maybe is null
    
    Since:
    
    2.2
  - fromRunnable
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable fromRunnable(@NonNull Runnable run)
```
    Returns a Completable instance that runs the given Runnable for each CompletableObserver and emits either its unchecked exception or simply completes.
    
    If the code to be wrapped needs to throw a checked or more broader Throwable exception, that exception has to be converted to an unchecked exception by the wrapped code itself. Alternatively, use the fromAction(Action) method which allows the wrapped code to throw any Throwable exception and will signal it to observers as-is.
    
    Scheduler:
    
    fromRunnable does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If the Runnable throws an exception, the respective Throwable is delivered to the downstream via CompletableObserver.onError(Throwable), except when the downstream has disposed this Completable source. In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) as an UndeliverableException.
    
    Parameters:
    
    run - the Runnable to run for each CompletableObserver
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if run is null
    
    See Also:
    
    fromAction(Action)
  - fromObservable
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Completable fromObservable(@NonNull ObservableSource<T> observable)
```
    Returns a Completable instance that subscribes to the given ObservableSource, ignores all values and emits only the terminal event.
    
    Scheduler:
    
    fromObservable does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the type of the ObservableSource
    
    Parameters:
    
    observable - the ObservableSource instance to subscribe to, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if observable is null
  - fromPublisher
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public static <T> @NonNull Completable fromPublisher(@NonNull Publisher<T> publisher)
```
    Returns a Completable instance that subscribes to the given Publisher, ignores all values and emits only the terminal event.
    
    The Publisher must follow the Reactive-Streams specification. Violating the specification may result in undefined behavior.
    If possible, use create(CompletableOnSubscribe) to create a source-like Completable instead.
    Note that even though Publisher appears to be a functional interface, it is not recommended to implement it through a lambda as the specification requires state management that is not achievable with a stateless lambda.
    
    Backpressure:
    
    The returned Completable honors the backpressure of the downstream consumer and expects the other Publisher to honor it as well.
    
    Scheduler:
    
    fromPublisher does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the type of the Publisher
    
    Parameters:
    
    publisher - the Publisher instance to subscribe to, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if publisher is null
    
    See Also:
    
    create(CompletableOnSubscribe)
  - fromSingle
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Completable fromSingle(@NonNull SingleSource<T> single)
```
    Returns a Completable instance that when subscribed to, subscribes to the SingleSource instance and emits a completion event if the single emits onSuccess or forwards any onError events.
    
    Scheduler:
    
    fromSingle does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type of the SingleSource
    
    Parameters:
    
    single - the SingleSource instance to subscribe to, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if single is null
  - fromSupplier
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable fromSupplier(@NonNull Supplier<?> supplier)
```
    Returns a Completable which when subscribed, executes the Supplier function, ignores its normal result and emits onError or onComplete only.
    
    Scheduler:
    
    fromSupplier does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If the Supplier throws an exception, the respective Throwable is delivered to the downstream via CompletableObserver.onError(Throwable), except when the downstream has disposed this Completable source. In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) as an UndeliverableException.
    
    Parameters:
    
    supplier - the Supplier instance to execute for each CompletableObserver
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if supplier is null
    
    Since:
    
    3.0.0
    
    See Also:
    
    defer(Supplier), fromCallable(Callable)
  - mergeArray
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @SafeVarargs
public static @NonNull Completable mergeArray(@NonNull CompletableSource... sources)
```
    Returns a Completable instance that subscribes to all sources at once and completes only when all source CompletableSources complete or one of them emits an error.
    
    Scheduler:
    
    mergeArray does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If any of the source CompletableSources signal a Throwable via onError, the resulting Completable terminates with that Throwable and all other source CompletableSources are disposed. If more than one CompletableSource signals an error, the resulting Completable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Completable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeArrayDelayError(CompletableSource...) to merge sources and terminate only when all source CompletableSources have completed or failed with an error.
    
    Parameters:
    
    sources - the array of CompletableSources.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    See Also:
    
    mergeArrayDelayError(CompletableSource...)
  - merge
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable merge(@NonNull Iterable<? extends CompletableSource> sources)
```
    Returns a Completable instance that subscribes to all sources at once and completes only when all source CompletableSources complete or one of them emits an error.
    
    Scheduler:
    
    merge does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If any of the source CompletableSources signal a Throwable via onError, the resulting Completable terminates with that Throwable and all other source CompletableSources are disposed. If more than one CompletableSource signals an error, the resulting Completable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Completable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Iterable) to merge sources and terminate only when all source CompletableSources have completed or failed with an error.
    
    Parameters:
    
    sources - the Iterable sequence of CompletableSources.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    See Also:
    
    mergeDelayError(Iterable)
  - merge
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=UNBOUNDED_IN)
 @NonNull
public static @NonNull Completable merge(@NonNull Publisher<? extends CompletableSource> sources)
```
    Returns a Completable instance that subscribes to all sources at once and completes only when all source CompletableSources complete or one of them emits an error.
    
    Backpressure:
    
    The operator consumes the given Publisher in an unbounded manner (requesting Long.MAX_VALUE upfront).
    
    Scheduler:
    
    merge does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If any of the source CompletableSources signal a Throwable via onError, the resulting Completable terminates with that Throwable and all other source CompletableSources are disposed. If more than one CompletableSource signals an error, the resulting Completable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Completable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher) to merge sources and terminate only when all source CompletableSources have completed or failed with an error.
    
    Parameters:
    
    sources - the Publisher sequence of CompletableSources.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    See Also:
    
    mergeDelayError(Publisher)
  - merge
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
 @NonNull
public static @NonNull Completable merge(@NonNull Publisher<? extends CompletableSource> sources,
        int maxConcurrency)
```
    Returns a Completable instance that keeps subscriptions to a limited number of sources at once and completes only when all source CompletableSources complete or one of them emits an error.
    
    Backpressure:
    
    The operator consumes the given Publisher in a bounded manner, requesting maxConcurrency items first, then keeps requesting as many more as the inner CompletableSources terminate.
    
    Scheduler:
    
    merge does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If any of the source CompletableSources signal a Throwable via onError, the resulting Completable terminates with that Throwable and all other source CompletableSources are disposed. If more than one CompletableSource signals an error, the resulting Completable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Completable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher, int) to merge sources and terminate only when all source CompletableSources have completed or failed with an error.
    
    Parameters:
    
    sources - the Publisher sequence of CompletableSources.
    
    maxConcurrency - the maximum number of concurrent subscriptions
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    IllegalArgumentException - if maxConcurrency is less than 1
    
    See Also:
    
    mergeDelayError(Publisher, int)
  - mergeArrayDelayError
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @SafeVarargs
public static @NonNull Completable mergeArrayDelayError(@NonNull CompletableSource... sources)
```
    Returns a Completable that subscribes to all CompletableSources in the source array and delays any error emitted by any of the inner CompletableSources until all of them terminate in a way or another.
    
    Scheduler:
    
    mergeArrayDelayError does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the array of CompletableSources
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - mergeDelayError
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable mergeDelayError(@NonNull Iterable<? extends CompletableSource> sources)
```
    Returns a Completable that subscribes to all CompletableSources in the source sequence and delays any error emitted by any of the inner CompletableSources until all of them terminate in a way or another.
    
    Scheduler:
    
    mergeDelayError does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sequence of CompletableSources
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - mergeDelayError
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=UNBOUNDED_IN)
 @NonNull
public static @NonNull Completable mergeDelayError(@NonNull Publisher<? extends CompletableSource> sources)
```
    Returns a Completable that subscribes to all CompletableSources in the source sequence and delays any error emitted by either the sources Publisher or any of the inner CompletableSources until all of them terminate in a way or another.
    
    Backpressure:
    
    The operator consumes the Publisher in an unbounded manner (requesting Long.MAX_VALUE from it).
    
    Scheduler:
    
    mergeDelayError does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sequence of CompletableSources
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - mergeDelayError
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
 @NonNull
public static @NonNull Completable mergeDelayError(@NonNull Publisher<? extends CompletableSource> sources,
        int maxConcurrency)
```
    Returns a Completable that subscribes to a limited number of inner CompletableSources at once in the source sequence and delays any error emitted by either the sources Publisher or any of the inner CompletableSources until all of them terminate in a way or another.
    
    Backpressure:
    
    The operator requests maxConcurrency items from the Publisher upfront and keeps requesting as many more as many inner CompletableSources terminate.
    
    Scheduler:
    
    mergeDelayError does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sequence of CompletableSources
    
    maxConcurrency - the maximum number of concurrent subscriptions to have at a time to the inner CompletableSources
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    IllegalArgumentException - if maxConcurrency is non-positive
  - never
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static @NonNull Completable never()
```
    Returns a Completable that never calls onError or onComplete.
    
    Scheduler:
    
    never does not operate by default on a particular Scheduler.
    
    Returns:
    
    the singleton instance that never calls onError or onComplete
  - timer
```
@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public static @NonNull Completable timer(long delay,
        @NonNull TimeUnit unit)
```
    Returns a Completable instance that fires its onComplete event after the given delay elapsed.
    
    Scheduler:
    
    timer does operate by default on the computation Scheduler.
    
    Parameters:
    
    delay - the delay time
    
    unit - the delay unit
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit is null
  - timer
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public static @NonNull Completable timer(long delay,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)
```
    Returns a Completable instance that fires its onComplete event after the given delay elapsed by using the supplied Scheduler.
    
    Scheduler:
    
    timer operates on the Scheduler you specify.
    
    Parameters:
    
    delay - the delay time
    
    unit - the delay unit
    
    scheduler - the Scheduler where to emit the onComplete event
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit or scheduler is null
  - switchOnNext
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=UNBOUNDED_IN)
public static @NonNull Completable switchOnNext(@NonNull Publisher<? extends CompletableSource> sources)
```
    Switches between CompletableSources emitted by the source Publisher whenever a new CompletableSource is emitted, disposing the previously running CompletableSource, exposing the setup as a Completable sequence.
    
    Backpressure:
    
    The sources Publisher is consumed in an unbounded manner (requesting Long.MAX_VALUE).
    
    Scheduler:
    
    switchOnNext does not operate by default on a particular Scheduler.
    
    Error handling:
    
    The returned sequence fails with the first error signaled by the sources Publisher or the currently running CompletableSource, disposing the rest. Late errors are forwarded to the global error handler via RxJavaPlugins.onError(Throwable).
    
    Parameters:
    
    sources - the Publisher sequence of inner CompletableSources to switch between
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    Since:
    
    3.0.0
    
    See Also:
    
    switchOnNextDelayError(Publisher), ReactiveX operators documentation: Switch
  - switchOnNextDelayError
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=UNBOUNDED_IN)
public static @NonNull Completable switchOnNextDelayError(@NonNull Publisher<? extends CompletableSource> sources)
```
    Switches between CompletableSources emitted by the source Publisher whenever a new CompletableSource is emitted, disposing the previously running CompletableSource, exposing the setup as a Completable sequence and delaying all errors from all of them until all terminate.
    
    Backpressure:
    
    The sources Publisher is consumed in an unbounded manner (requesting Long.MAX_VALUE).
    
    Scheduler:
    
    switchOnNextDelayError does not operate by default on a particular Scheduler.
    
    Error handling:
    
    The returned Completable collects all errors emitted by either the sources Publisher or any inner CompletableSource and emits them as a CompositeException when all sources terminate. If only one source ever failed, its error is emitted as-is at the end.
    
    Parameters:
    
    sources - the Publisher sequence of inner CompletableSources to switch between
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    Since:
    
    3.0.0
    
    See Also:
    
    switchOnNext(Publisher), ReactiveX operators documentation: Switch
  - using
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <R> @NonNull Completable using(@NonNull Supplier<R> resourceSupplier,
        @NonNull Function<? super R,? extends CompletableSource> sourceSupplier,
        @NonNull Consumer<? super R> resourceCleanup)
```
    Returns a Completable instance which manages a resource along with a custom CompletableSource instance while the subscription is active.
    
    This overload disposes eagerly before the terminal event is emitted.
    
    Scheduler:
    
    using does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    R - the resource type
    
    Parameters:
    
    resourceSupplier - the Supplier that returns a resource to be managed.
    
    sourceSupplier - the Function that given a resource returns a CompletableSource instance that will be subscribed to
    
    resourceCleanup - the Consumer that disposes the resource created by the resource supplier
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if resourceSupplier, sourceSupplier or resourceCleanup is null
  - using
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <R> @NonNull Completable using(@NonNull Supplier<R> resourceSupplier,
        @NonNull Function<? super R,? extends CompletableSource> sourceSupplier,
        @NonNull Consumer<? super R> resourceCleanup,
        boolean eager)
```
    Returns a Completable instance which manages a resource along with a custom CompletableSource instance while the subscription is active and performs eager or lazy resource disposition.
    
    If this overload performs a lazy disposal after the terminal event is emitted. The exceptions thrown at this time will be delivered to the global RxJavaPlugins.onError(Throwable) handler only.
    
    Scheduler:
    
    using does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    R - the resource type
    
    Parameters:
    
    resourceSupplier - the Supplier that returns a resource to be managed
    
    sourceSupplier - the Function that given a resource returns a non-null CompletableSource instance that will be subscribed to
    
    resourceCleanup - the Consumer that disposes the resource created by the resource supplier
    
    eager - If true then resource disposal will happen either on a dispose() call before the upstream is disposed or just before the emission of a terminal event (onComplete or onError). If false the resource disposal will happen either on a dispose() call after the upstream is disposed or just after the emission of a terminal event (onComplete or onError).
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if resourceSupplier, sourceSupplier or resourceCleanup is null
  - wrap
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static @NonNull Completable wrap(@NonNull CompletableSource source)
```
    Wraps the given CompletableSource into a Completable if not already Completable.
    
    Scheduler:
    
    wrap does not operate by default on a particular Scheduler.
    
    Parameters:
    
    source - the source to wrap
    
    Returns:
    
    the new wrapped or cast Completable instance
    
    Throws:
    
    NullPointerException - if source is null
  - ambWith
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable ambWith(@NonNull CompletableSource other)
```
    Returns a Completable that emits the a terminated event of either this Completable or the other CompletableSource, whichever fires first.
    
    Scheduler:
    
    ambWith does not operate by default on a particular Scheduler.
    
    Parameters:
    
    other - the other CompletableSource, not null. A subscription to this provided source will occur after subscribing to the current source.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if other is null
  - andThen
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <T> @NonNull Observable<T> andThen(@NonNull ObservableSource<T> next)
```
    Returns an Observable which will subscribe to this Completable and once that is completed then will subscribe to the next ObservableSource. An error event from this Completable will be propagated to the downstream observer and will result in skipping the subscription to the next ObservableSource.
    
    Scheduler:
    
    andThen does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type of the next ObservableSource
    
    Parameters:
    
    next - the ObservableSource to subscribe after this Completable is completed, not null
    
    Returns:
    
    the new Observable that composes this Completable and the next ObservableSource
    
    Throws:
    
    NullPointerException - if next is null
  - andThen
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <T> @NonNull Flowable<T> andThen(@NonNull Publisher<T> next)
```
    Returns a Flowable which will subscribe to this Completable and once that is completed then will subscribe to the next Publisher. An error event from this Completable will be propagated to the downstream subscriber and will result in skipping the subscription to the next Publisher.
    
    Backpressure:
    
    The returned Flowable honors the backpressure of the downstream consumer and expects the other Publisher to honor it as well.
    
    Scheduler:
    
    andThen does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type of the next Publisher
    
    Parameters:
    
    next - the Publisher to subscribe after this Completable is completed, not null
    
    Returns:
    
    the new Flowable that composes this Completable and the next Publisher
    
    Throws:
    
    NullPointerException - if next is null
  - andThen
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <T> @NonNull Single<T> andThen(@NonNull SingleSource<T> next)
```
    Returns a Single which will subscribe to this Completable and once that is completed then will subscribe to the next SingleSource. An error event from this Completable will be propagated to the downstream observer and will result in skipping the subscription to the next SingleSource.
    
    Scheduler:
    
    andThen does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type of the next SingleSource
    
    Parameters:
    
    next - the SingleSource to subscribe after this Completable is completed, not null
    
    Returns:
    
    the new Single that composes this Completable and the next SingleSource
    
    Throws:
    
    NullPointerException - if next is null
  - andThen
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <T> @NonNull Maybe<T> andThen(@NonNull MaybeSource<T> next)
```
    Returns a Maybe which will subscribe to this Completable and once that is completed then will subscribe to the next MaybeSource. An error event from this Completable will be propagated to the downstream observer and will result in skipping the subscription to the next MaybeSource.
    
    Scheduler:
    
    andThen does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type of the next MaybeSource
    
    Parameters:
    
    next - the MaybeSource to subscribe after this Completable is completed, not null
    
    Returns:
    
    the new Maybe that composes this Completable and the next MaybeSource
    
    Throws:
    
    NullPointerException - if next is null
  - andThen
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable andThen(@NonNull CompletableSource next)
```
    Returns a Completable that first runs this Completable and then the other CompletableSource. An error event from this Completable will be propagated to the downstream observer and will result in skipping the subscription to the next CompletableSource.
    
    This is an alias for concatWith(CompletableSource).
    
    Scheduler:
    
    andThen does not operate by default on a particular Scheduler.
    
    Parameters:
    
    next - the other CompletableSource, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if next is null
  - blockingAwait
```
@SchedulerSupport(value="none")
public final void blockingAwait()
```
    Subscribes to and awaits the termination of this Completable instance in a blocking manner and rethrows any exception emitted.
    
    Scheduler:
    
    blockingAwait does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.
    
    Throws:
    
    RuntimeException - wrapping an InterruptedException if the current thread is interrupted
  - blockingAwait
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final boolean blockingAwait(long timeout,
        @NonNull TimeUnit unit)
```
    Subscribes to and awaits the termination of this Completable instance in a blocking manner with a specific timeout and rethrows any exception emitted within the timeout window.
    
    Scheduler:
    
    blockingAwait does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the timeout unit
    
    Returns:
    
    true if the this Completable instance completed normally within the time limit, false if the timeout elapsed before this Completable terminated.
    
    Throws:
    
    RuntimeException - wrapping an InterruptedException if the current thread is interrupted
    
    NullPointerException - if unit is null
  - blockingSubscribe
```
@SchedulerSupport(value="none")
public final void blockingSubscribe()
```
    Subscribes to the current Completable and blocks the current thread until it terminates.
    
    Scheduler:
    
    blockingSubscribe does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If the current Completable signals an error, the Throwable is routed to the global error handler via RxJavaPlugins.onError(Throwable). If the current thread is interrupted, an InterruptedException is routed to the same global error handler.
    
    Since:
    
    3.0.0
    
    See Also:
    
    blockingSubscribe(Action), blockingSubscribe(Action, Consumer)
  - blockingSubscribe
```
@SchedulerSupport(value="none")
public final void blockingSubscribe(@NonNull Action onComplete)
```
    Subscribes to the current Completable and calls given onComplete callback on the current thread when it completes normally.
    
    Scheduler:
    
    blockingSubscribe does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If either the current Completable signals an error or onComplete throws, the respective Throwable is routed to the global error handler via RxJavaPlugins.onError(Throwable). If the current thread is interrupted, an InterruptedException is routed to the same global error handler.
    
    Parameters:
    
    onComplete - the Action to call if the current Completable completes normally
    
    Throws:
    
    NullPointerException - if onComplete is null
    
    Since:
    
    3.0.0
    
    See Also:
    
    blockingSubscribe(Action, Consumer)
  - blockingSubscribe
```
@SchedulerSupport(value="none")
public final void blockingSubscribe(@NonNull Action onComplete,
        @NonNull Consumer<? super Throwable> onError)
```
    Subscribes to the current Completable and calls the appropriate callback on the current thread when it terminates.
    
    Scheduler:
    
    blockingSubscribe does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If either onComplete or onError throw, the Throwable is routed to the global error handler via RxJavaPlugins.onError(Throwable). If the current thread is interrupted, the onError consumer is called with an InterruptedException.
    
    Parameters:
    
    onComplete - the Action to call if the current Completable completes normally
    
    onError - the Consumer to call if the current Completable signals an error
    
    Throws:
    
    NullPointerException - if onComplete or onError is null
    
    Since:
    
    3.0.0
  - blockingSubscribe
```
@SchedulerSupport(value="none")
public final void blockingSubscribe(@NonNull CompletableObserver observer)
```
    Subscribes to the current Completable and calls the appropriate CompletableObserver method on the current thread.
    
    Scheduler:
    
    blockingSubscribe does not operate by default on a particular Scheduler.
    
    Error handling:
    
    An onError signal is delivered to the CompletableObserver.onError(Throwable) method. If any of the CompletableObserver's methods throw, the RuntimeException is propagated to the caller of this method. If the current thread is interrupted, an InterruptedException is delivered to observer.onError.
    
    Parameters:
    
    observer - the CompletableObserver to call methods on the current thread
    
    Throws:
    
    NullPointerException - if observer is null
    
    Since:
    
    3.0.0
  - cache
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable cache()
```
    Subscribes to this Completable only once, when the first CompletableObserver subscribes to the result Completable, caches its terminal event and relays/replays it to observers.
    
    Note that this operator doesn't allow disposing the connection of the upstream source.
    
    Scheduler:
    
    cache does not operate by default on a particular Scheduler.
    
    History: 2.0.4 - experimental
    
    Returns:
    
    the new Completable instance
    
    Since:
    
    2.1
  - compose
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable compose(@NonNull CompletableTransformer transformer)
```
    Calls the given transformer function with this instance and returns the function's resulting CompletableSource wrapped with wrap(CompletableSource).
    
    Scheduler:
    
    compose does not operate by default on a particular Scheduler.
    
    Parameters:
    
    transformer - the transformer function, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if transformer is null
  - concatWith
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable concatWith(@NonNull CompletableSource other)
```
    Concatenates this Completable with another CompletableSource. An error event from this Completable will be propagated to the downstream observer and will result in skipping the subscription to the next CompletableSource.
    
    Scheduler:
    
    concatWith does not operate by default on a particular Scheduler.
    
    Parameters:
    
    other - the other CompletableSource, not null
    
    Returns:
    
    the new Completable which subscribes to this and then the other CompletableSource
    
    Throws:
    
    NullPointerException - if other is null
    
    See Also:
    
    andThen(CompletableSource), andThen(MaybeSource), andThen(ObservableSource), andThen(SingleSource), andThen(Publisher)
  - delay
```
@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Completable delay(long time,
        @NonNull TimeUnit unit)
```
    Returns a Completable which delays the emission of the completion event by the given time.
    
    Scheduler:
    
    delay does operate by default on the computation Scheduler.
    
    Parameters:
    
    time - the delay time
    
    unit - the delay unit
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit is null
  - delay
```
@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Completable delay(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)
```
    Returns a Completable which delays the emission of the completion event by the given time while running on the specified Scheduler.
    
    Scheduler:
    
    delay operates on the Scheduler you specify.
    
    Parameters:
    
    time - the delay time
    
    unit - the delay unit
    
    scheduler - the Scheduler to run the delayed completion on
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit or scheduler is null
  - delay
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Completable delay(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean delayError)
```
    Returns a Completable which delays the emission of the completion event, and optionally the error as well, by the given time while running on the specified Scheduler.
    
    Scheduler:
    
    delay operates on the Scheduler you specify.
    
    Parameters:
    
    time - the delay time
    
    unit - the delay unit
    
    scheduler - the Scheduler to run the delayed completion on
    
    delayError - delay the error emission as well?
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit or scheduler is null
  - delaySubscription
```
@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Completable delaySubscription(long time,
        @NonNull TimeUnit unit)
```
    Returns a Completable that delays the subscription to the upstream by a given amount of time.
    
    Scheduler:
    
    This version of delaySubscription operates by default on the computation Scheduler.
    
    History: 2.2.3 - experimental
    
    Parameters:
    
    time - the time to delay the subscription
    
    unit - the time unit of delay
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit is null
    
    Since:
    
    3.0.0
    
    See Also:
    
    ReactiveX operators documentation: Delay
  - delaySubscription
```
@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Completable delaySubscription(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)
```
    Returns a Completable that delays the subscription to the upstream by a given amount of time, both waiting and subscribing on a given Scheduler.
    
    Scheduler:
    
    You specify which Scheduler this operator will use.
    
    History: 2.2.3 - experimental
    
    Parameters:
    
    time - the time to delay the subscription
    
    unit - the time unit of delay
    
    scheduler - the Scheduler on which the waiting and subscription will happen
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit or scheduler is null
    
    Since:
    
    3.0.0
    
    See Also:
    
    ReactiveX operators documentation: Delay
  - doOnComplete
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable doOnComplete(@NonNull Action onComplete)
```
    Returns a Completable which calls the given onComplete Action if this Completable completes.
    
    Scheduler:
    
    doOnComplete does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onComplete - the Action to call when this emits an onComplete event
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onComplete is null
    
    See Also:
    
    doFinally(Action)
  - doOnDispose
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable doOnDispose(@NonNull Action onDispose)
```
    Calls the shared Action if a CompletableObserver subscribed to the current Completable disposes the common Disposable it received via onSubscribe.
    
    Scheduler:
    
    doOnDispose does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onDispose - the Action to call when the downstream observer disposes the subscription
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onDispose is null
  - doOnError
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable doOnError(@NonNull Consumer<? super Throwable> onError)
```
    Returns a Completable which calls the given onError Consumer if this Completable emits an error.
    
    Scheduler:
    
    doOnError does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onError - the error Consumer receiving the upstream Throwable if the upstream signals it via onError
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onError is null
    
    See Also:
    
    doFinally(Action)
  - doOnEvent
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable doOnEvent(@NonNull Consumer<? super Throwable> onEvent)
```
    Returns a Completable which calls the given onEvent Consumer with the Throwable for an onError or null for an onComplete signal from this Completable before delivering the signal to the downstream.
    
    Scheduler:
    
    doOnEvent does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onEvent - the event Consumer that receives null for upstream completion or a Throwable if the upstream signaled an error
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onEvent is null
  - doOnLifecycle
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe,
        @NonNull Action onDispose)
```
    Calls the appropriate onXXX method (shared between all CompletableObservers) for the lifecycle events of the sequence (subscription, disposal).
    
    Scheduler:
    
    doOnLifecycle does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onSubscribe - a Consumer called with the Disposable sent via CompletableObserver.onSubscribe(Disposable)
    
    onDispose - called when the downstream disposes the Disposable via dispose()
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onSubscribe or onDispose is null
    
    Since:
    
    3.0.0
    
    See Also:
    
    ReactiveX operators documentation: Do
  - doOnSubscribe
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)
```
    Returns a Completable instance that calls the given onSubscribe callback with the disposable that the downstream CompletableObservers receive upon subscription.
    
    Scheduler:
    
    doOnSubscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onSubscribe - the Consumer called when a downstream CompletableObserver subscribes
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onSubscribe is null
  - doOnTerminate
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable doOnTerminate(@NonNull Action onTerminate)
```
    Returns a Completable instance that calls the given onTerminate Action just before this Completable completes normally or with an exception.
    
    Scheduler:
    
    doOnTerminate does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onTerminate - the Action to call just before this Completable terminates
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onTerminate is null
    
    See Also:
    
    doFinally(Action)
  - doAfterTerminate
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable doAfterTerminate(@NonNull Action onAfterTerminate)
```
    Returns a Completable instance that calls the given onAfterTerminate Action after this Completable completes normally or with an exception.
    
    Scheduler:
    
    doAfterTerminate does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onAfterTerminate - the Action to call after this Completable terminates
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onAfterTerminate is null
    
    See Also:
    
    doFinally(Action)
  - doFinally
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable doFinally(@NonNull Action onFinally)
```
    Calls the specified Action after this Completable signals onError or onComplete or gets disposed by the downstream.
    
    In case of a race between a terminal event and a dispose call, the provided onFinally action is executed once per subscription.
    Note that the onFinally action is shared between subscriptions and as such should be thread-safe.
    
    Scheduler:
    
    doFinally does not operate by default on a particular Scheduler.
    
    History: 2.0.1 - experimental
    
    Parameters:
    
    onFinally - the Action called when this Completable terminates or gets disposed
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onFinally is null
    
    Since:
    
    2.1
  - lift
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable lift(@NonNull CompletableOperator onLift)
```
    This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a Completable which, when subscribed to, invokes the apply(CompletableObserver) method of the provided CompletableOperator for each individual downstream Completable and allows the insertion of a custom operator by accessing the downstream's CompletableObserver during this subscription phase and providing a new CompletableObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
    
    Generally, such a new CompletableObserver will wrap the downstream's CompletableObserver and forwards the onError and onComplete events from the upstream directly or according to the emission pattern the custom operator's business logic requires. In addition, such operator can intercept the flow control calls of dispose and isDisposed that would have traveled upstream and perform additional actions depending on the same business logic requirements.
    Example:
```
 // Step 1: Create the consumer type that will be returned by the CompletableOperator.apply():
 
 public final class CustomCompletableObserver implements CompletableObserver, Disposable {

     // The downstream's CompletableObserver that will receive the onXXX events
     final CompletableObserver downstream;

     // The connection to the upstream source that will call this class' onXXX methods
     Disposable upstream;

     // The constructor takes the downstream subscriber and usually any other parameters
     public CustomCompletableObserver(CompletableObserver downstream) {
         this.downstream = downstream;
     }

     // In the subscription phase, the upstream sends a Disposable to this class
     // and subsequently this class has to send a Disposable to the downstream.
     // Note that relaying the upstream's Disposable directly is not allowed in RxJava
     @Override
     public void onSubscribe(Disposable d) {
         if (upstream != null) {
             d.dispose();
         } else {
             upstream = d;
             downstream.onSubscribe(this);
         }
     }

     // Some operators may handle the upstream's error while others
     // could just forward it to the downstream.
     @Override
     public void onError(Throwable throwable) {
         downstream.onError(throwable);
     }

     // When the upstream completes, usually the downstream should complete as well.
     // In completable, this could also mean doing some side-effects
     @Override
     public void onComplete() {
         System.out.println("Sequence completed");
         downstream.onComplete();
     }

     // Some operators may use their own resources which should be cleaned up if
     // the downstream disposes the flow before it completed. Operators without
     // resources can simply forward the dispose to the upstream.
     // In some cases, a disposed flag may be set by this method so that other parts
     // of this class may detect the dispose and stop sending events
     // to the downstream.
     @Override
     public void dispose() {
         upstream.dispose();
     }

     // Some operators may simply forward the call to the upstream while others
     // can return the disposed flag set in dispose().
     @Override
     public boolean isDisposed() {
         return upstream.isDisposed();
     }
 }

 // Step 2: Create a class that implements the CompletableOperator interface and
 //         returns the custom consumer type from above in its apply() method.
 //         Such class may define additional parameters to be submitted to
 //         the custom consumer type.

 final class CustomCompletableOperator implements CompletableOperator {
     @Override
     public CompletableObserver apply(CompletableObserver upstream) {
         return new CustomCompletableObserver(upstream);
     }
 }

 // Step 3: Apply the custom operator via lift() in a flow by creating an instance of it
 //         or reusing an existing one.

 Completable.complete()
 .lift(new CustomCompletableOperator())
 .test()
 .assertResult();
 
```
    Creating custom operators can be complicated and it is recommended one consults the RxJava wiki: Writing operators page about the tools, requirements, rules, considerations and pitfalls of implementing them.
    Note that implementing custom operators via this lift() method adds slightly more overhead by requiring an additional allocation and indirection per assembled flows. Instead, extending the abstract Completable class and creating a CompletableTransformer with it is recommended.
    Note also that it is not possible to stop the subscription phase in lift() as the apply() method requires a non-null CompletableObserver instance to be returned, which is then unconditionally subscribed to the current Completable. For example, if the operator decided there is no reason to subscribe to the upstream source because of some optimization possibility or a failure to prepare the operator, it still has to return a CompletableObserver that should immediately dispose the upstream's Disposable in its onSubscribe method. Again, using a CompletableTransformer and extending the Completable is a better option as subscribeActual(io.reactivex.rxjava3.core.CompletableObserver) can decide to not subscribe to its upstream after all.
    
    Scheduler:
    
    lift does not operate by default on a particular Scheduler, however, the CompletableOperator may use a Scheduler to support its own asynchronous behavior.
    Parameters:
    
    onLift - the CompletableOperator that receives the downstream's CompletableObserver and should return a CompletableObserver with custom behavior to be used as the consumer for the current Completable.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onLift is null
    
    See Also:
    
    RxJava wiki: Writing operators, compose(CompletableTransformer)
  - materialize
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <T> @NonNull Single<Notification<T>> materialize()
```
    Maps the signal types of this Completable into a Notification of the same kind and emits it as a single success value to downstream.
    
    Scheduler:
    
    materialize does not operate by default on a particular Scheduler.
    
    History: 2.2.4 - experimental
    
    Type Parameters:
    
    T - the intended target element type of the Notification
    
    Returns:
    
    the new Single instance
    
    Since:
    
    3.0.0
    
    See Also:
    
    Single.dematerialize(Function)
  - mergeWith
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable mergeWith(@NonNull CompletableSource other)
```
    Returns a Completable which subscribes to this and the other CompletableSource and completes when both of them complete or one emits an error.
    
    Scheduler:
    
    mergeWith does not operate by default on a particular Scheduler.
    
    Parameters:
    
    other - the other CompletableSource instance
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if other is null
  - observeOn
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Completable observeOn(@NonNull Scheduler scheduler)
```
    Returns a Completable which emits the terminal events from the thread of the specified Scheduler.
    
    Scheduler:
    
    observeOn operates on a Scheduler you specify.
    
    Parameters:
    
    scheduler - the Scheduler to emit terminal events on
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if scheduler is null
  - onErrorComplete
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable onErrorComplete()
```
    Returns a Completable instance that if this Completable emits an error, it will emit an onComplete and swallow the upstream Throwable.
    
    Scheduler:
    
    onErrorComplete does not operate by default on a particular Scheduler.
    
    Returns:
    
    the new Completable instance
  - onErrorComplete
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable onErrorComplete(@NonNull Predicate<? super Throwable> predicate)
```
    Returns a Completable instance that if this Completable emits an error and the Predicate returns true, it will emit an onComplete and swallow the Throwable.
    
    Scheduler:
    
    onErrorComplete does not operate by default on a particular Scheduler.
    
    Parameters:
    
    predicate - the Predicate to call when a Throwable is emitted which should return true if the Throwable should be swallowed and replaced with an onComplete.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if predicate is null
  - onErrorResumeNext
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable onErrorResumeNext(@NonNull Function<? super Throwable,? extends CompletableSource> fallbackSupplier)
```
    Returns a Completable instance that when encounters an error from this Completable, calls the specified mapper Function that returns a CompletableSource instance for it and resumes the execution with it.
    
    Scheduler:
    
    onErrorResumeNext does not operate by default on a particular Scheduler.
    
    Parameters:
    
    fallbackSupplier - the mapper Function that takes the error and should return a CompletableSource as continuation.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if fallbackSupplier is null
  - onErrorResumeWith
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable onErrorResumeWith(@NonNull CompletableSource fallback)
```
    Resumes the flow with the given CompletableSource when the current Completable fails instead of signaling the error via onError.
    
    You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
    
    Scheduler:
    
    onErrorResumeWith does not operate by default on a particular Scheduler.
    
    Parameters:
    
    fallback - the next CompletableSource that will take over if the current Completable encounters an error
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if fallback is null
    
    Since:
    
    3.0.0
    
    See Also:
    
    ReactiveX operators documentation: Catch
  - onErrorReturn
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <T> @NonNull Maybe<T> onErrorReturn(@NonNull Function<? super Throwable,? extends T> itemSupplier)
```
    Ends the flow with a success item returned by a function for the Throwable error signaled by the current Completable instead of signaling the error via onError.
    
    You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
    
    Scheduler:
    
    onErrorReturn does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the item type to return on error
    
    Parameters:
    
    itemSupplier - a function that returns a single value that will be emitted as success value the current Completable signals an onError event
    
    Returns:
    
    the new Maybe instance
    
    Throws:
    
    NullPointerException - if itemSupplier is null
    
    Since:
    
    3.0.0
    
    See Also:
    
    ReactiveX operators documentation: Catch
  - onErrorReturnItem
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <T> @NonNull Maybe<T> onErrorReturnItem(@NonNull T item)
```
    Ends the flow with the given success item when the current Completable fails instead of signaling the error via onError.
    
    You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
    
    Scheduler:
    
    onErrorReturnItem does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the item type to return on error
    
    Parameters:
    
    item - the value that is emitted as onSuccess in case the current Completable signals an onError
    
    Returns:
    
    the new Maybe instance
    
    Throws:
    
    NullPointerException - if item is null
    
    See Also:
    
    ReactiveX operators documentation: Catch
  - onTerminateDetach
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable onTerminateDetach()
```
    Nulls out references to the upstream producer and downstream CompletableObserver if the sequence is terminated or downstream calls dispose().
    
    Scheduler:
    
    onTerminateDetach does not operate by default on a particular Scheduler.
    
    History: 2.1.5 - experimental
    
    Returns:
    
    the new Completable instance
    
    Since:
    
    2.2
  - repeat
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable repeat()
```
    Returns a Completable that repeatedly subscribes to this Completable until disposed.
    
    Scheduler:
    
    repeat does not operate by default on a particular Scheduler.
    
    Returns:
    
    the new Completable instance
  - repeat
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable repeat(long times)
```
    Returns a Completable that subscribes repeatedly at most the given number of times to this Completable.
    
    Scheduler:
    
    repeat does not operate by default on a particular Scheduler.
    
    Parameters:
    
    times - the number of times the re-subscription should happen
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    IllegalArgumentException - if times is negative
  - repeatUntil
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable repeatUntil(@NonNull BooleanSupplier stop)
```
    Returns a Completable that repeatedly subscribes to this Completable so long as the given stop BooleanSupplier returns false.
    
    Scheduler:
    
    repeatUntil does not operate by default on a particular Scheduler.
    
    Parameters:
    
    stop - the BooleanSupplier that should return true to stop resubscribing.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if stop is null
  - repeatWhen
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable repeatWhen(@NonNull Function<? super Flowable<Object>,? extends Publisher<?>> handler)
```
    Returns a Completable instance that repeats when the Publisher returned by the handler Function emits an item or completes when this Publisher emits an onComplete event.
    
    Scheduler:
    
    repeatWhen does not operate by default on a particular Scheduler.
    
    Parameters:
    
    handler - the Function that transforms the stream of values indicating the completion of this Completable and returns a Publisher that emits items for repeating or completes to indicate the repetition should stop
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if handler is null
  - retry
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable retry()
```
    Returns a Completable that retries this Completable as long as it emits an onError event.
    
    Scheduler:
    
    retry does not operate by default on a particular Scheduler.
    
    Returns:
    
    the new Completable instance
  - retry
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable retry(@NonNull BiPredicate<? super Integer,? super Throwable> predicate)
```
    Returns a Completable that retries this Completable in case of an error as long as the predicate returns true.
    
    Scheduler:
    
    retry does not operate by default on a particular Scheduler.
    
    Parameters:
    
    predicate - the Predicate called when this Completable emits an error with the repeat count and the latest Throwable and should return true to retry.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if predicate is null
  - retry
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable retry(long times)
```
    Returns a Completable that when this Completable emits an error, retries at most the given number of times before giving up and emitting the last error.
    
    Scheduler:
    
    retry does not operate by default on a particular Scheduler.
    
    Parameters:
    
    times - the number of times to resubscribe if the current Completable fails
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    IllegalArgumentException - if times is negative
  - retry
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable retry(long times,
        @NonNull Predicate<? super Throwable> predicate)
```
    Returns a Completable that when this Completable emits an error, retries at most times or until the predicate returns false, whichever happens first and emitting the last error.
    
    Scheduler:
    
    retry does not operate by default on a particular Scheduler.
    
    History: 2.1.8 - experimental
    
    Parameters:
    
    times - the number of times to resubscribe if the current Completable fails
    
    predicate - the Predicate that is called with the latest Throwable and should return true to indicate the returned Completable should resubscribe to this Completable.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if predicate is null
    
    IllegalArgumentException - if times is negative
    
    Since:
    
    2.2
  - retry
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable retry(@NonNull Predicate<? super Throwable> predicate)
```
    Returns a Completable that when this Completable emits an error, calls the given predicate with the latest Throwable to decide whether to resubscribe to the upstream or not.
    
    Scheduler:
    
    retry does not operate by default on a particular Scheduler.
    
    Parameters:
    
    predicate - the Predicate that is called with the latest Throwable and should return true to indicate the returned Completable should resubscribe to this Completable.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if predicate is null
  - retryUntil
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable retryUntil(@NonNull BooleanSupplier stop)
```
    Retries until the given stop function returns true.
    
    Scheduler:
    
    retryUntil does not operate by default on a particular Scheduler.
    
    Parameters:
    
    stop - the function that should return true to stop retrying
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if stop is null
    
    Since:
    
    3.0.0
  - retryWhen
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable retryWhen(@NonNull Function<? super Flowable<Throwable>,? extends Publisher<?>> handler)
```
    Returns a Completable which given a Publisher and when this Completable emits an error, delivers that error through a Flowable and the Publisher should signal a value indicating a retry in response or a terminal event indicating a termination.
    
    Note that the inner Publisher returned by the handler function should signal either onNext, onError or onComplete in response to the received Throwable to indicate the operator should retry or terminate. If the upstream to the operator is asynchronous, signaling onNext followed by onComplete immediately may result in the sequence to be completed immediately. Similarly, if this inner Publisher signals onError or onComplete while the upstream is active, the sequence is terminated with the same signal immediately.
    The following example demonstrates how to retry an asynchronous source with a delay:
```
 Completable.timer(1, TimeUnit.SECONDS)
     .doOnSubscribe(s -> System.out.println("subscribing"))
     .doOnComplete(() -> { throw new RuntimeException(); })
     .retryWhen(errors -> {
         AtomicInteger counter = new AtomicInteger();
         return errors
                   .takeWhile(e -> counter.getAndIncrement() != 3)
                   .flatMap(e -> {
                       System.out.println("delay retry by " + counter.get() + " second(s)");
                       return Flowable.timer(counter.get(), TimeUnit.SECONDS);
                   });
     })
     .blockingAwait();
 
```
    Scheduler:
    
    retryWhen does not operate by default on a particular Scheduler.
    Parameters:
    
    handler - the Function that receives a Flowable delivering Throwables and should return a Publisher that emits items to indicate retries or emits terminal events to indicate termination.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if handler is null
  - safeSubscribe
```
@SchedulerSupport(value="none")
public final void safeSubscribe(@NonNull CompletableObserver observer)
```
    Wraps the given CompletableObserver, catches any RuntimeExceptions thrown by its CompletableObserver.onSubscribe(Disposable), CompletableObserver.onError(Throwable) or CompletableObserver.onComplete() methods and routes those to the global error handler via RxJavaPlugins.onError(Throwable).
    By default, the Completable protocol forbids the onXXX methods to throw, but some CompletableObserver implementation may do it anyway, causing undefined behavior in the upstream. This method and the underlying safe wrapper ensures such misbehaving consumers don't disrupt the protocol.
    
    Scheduler:
    
    safeSubscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    
    observer - the potentially misbehaving CompletableObserver
    
    Throws:
    
    NullPointerException - if observer is null
    
    Since:
    
    3.0.0
    
    See Also:
    
    subscribe(Action, Consumer)
  - startWith
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable startWith(@NonNull CompletableSource other)
```
    Returns a Completable which first runs the other CompletableSource then the current Completable if the other completed normally.
    
    Scheduler:
    
    startWith does not operate by default on a particular Scheduler.
    
    Parameters:
    
    other - the other CompletableSource to run first
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if other is null
  - startWith
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public final <T> @NonNull Flowable<T> startWith(@NonNull SingleSource<T> other)
```
    Returns a Flowable which first runs the other SingleSource then the current Completable if the other succeeded normally.
    
    Backpressure:
    
    The returned Flowable honors the backpressure of the downstream consumer.
    
    Scheduler:
    
    startWith does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the element type of the other SingleSource.
    
    Parameters:
    
    other - the other SingleSource to run first
    
    Returns:
    
    the new Flowable instance
    
    Throws:
    
    NullPointerException - if other is null
    
    Since:
    
    3.0.0
  - startWith
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public final <T> @NonNull Flowable<T> startWith(@NonNull MaybeSource<T> other)
```
    Returns a Flowable which first runs the other MaybeSource then the current Completable if the other succeeded or completed normally.
    
    Backpressure:
    
    The returned Flowable honors the backpressure of the downstream consumer.
    
    Scheduler:
    
    startWith does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the element type of the other MaybeSource.
    
    Parameters:
    
    other - the other MaybeSource to run first
    
    Returns:
    
    the new Flowable instance
    
    Throws:
    
    NullPointerException - if other is null
    
    Since:
    
    3.0.0
  - startWith
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <T> @NonNull Observable<T> startWith(@NonNull ObservableSource<T> other)
```
    Returns an Observable which first delivers the events of the other ObservableSource then runs the current Completable.
    
    Scheduler:
    
    startWith does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    other - the other ObservableSource to run first
    
    Returns:
    
    the new Observable instance
    
    Throws:
    
    NullPointerException - if other is null
  - startWith
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <T> @NonNull Flowable<T> startWith(@NonNull Publisher<T> other)
```
    Returns a Flowable which first delivers the events of the other Publisher then runs the current Completable.
    
    Backpressure:
    
    The returned Flowable honors the backpressure of the downstream consumer and expects the other Publisher to honor it as well.
    
    Scheduler:
    
    startWith does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    other - the other Publisher to run first
    
    Returns:
    
    the new Flowable instance
    
    Throws:
    
    NullPointerException - if other is null
  - hide
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable hide()
```
    Hides the identity of this Completable and its Disposable.
    
    Allows preventing certain identity-based optimizations (fusion).
    
    Scheduler:
    
    hide does not operate by default on a particular Scheduler.
    
    History: 2.0.5 - experimental
    
    Returns:
    
    the new Completable instance
    
    Since:
    
    2.1
  - subscribe
```
@SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable subscribe()
```
    Subscribes to this Completable and returns a Disposable which can be used to dispose the subscription.
    
    Scheduler:
    
    subscribe does not operate by default on a particular Scheduler.
    
    Returns:
    
    the new Disposable that can be used for disposing the subscription at any time
    
    See Also:
    
    subscribe(Action, Consumer, DisposableContainer)
  - subscribe
```
@SchedulerSupport(value="none")
public final void subscribe(@NonNull CompletableObserver observer)
```
    Description copied from interface: CompletableSource
    
    Subscribes the given CompletableObserver to this CompletableSource instance.
    
    Specified by:
    
    subscribe in interface CompletableSource
    
    Parameters:
    
    observer - the CompletableObserver, not null
  - subscribeActual
```
protected abstract void subscribeActual(@NonNull CompletableObserver observer)
```
    Implement this method to handle the incoming CompletableObservers and perform the business logic in your operator.
    There is no need to call any of the plugin hooks on the current Completable instance or the CompletableObserver; all hooks and basic safeguards have been applied by subscribe(CompletableObserver) before this method gets called.
    
    Parameters:
    
    observer - the CompletableObserver instance, never null
  - subscribeWith
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <E extends CompletableObserver> E subscribeWith(E observer)
```
    Subscribes a given CompletableObserver (subclass) to this Completable and returns the given CompletableObserver as is.
    
    Usage example:
```
 Completable source = Completable.complete().delay(1, TimeUnit.SECONDS);
 CompositeDisposable composite = new CompositeDisposable();

 DisposableCompletableObserver ds = new DisposableCompletableObserver() {
     // ...
 };

 composite.add(source.subscribeWith(ds));
 
```
    Scheduler:
    
    subscribeWith does not operate by default on a particular Scheduler.
    Type Parameters:
    
    E - the type of the CompletableObserver to use and return
    
    Parameters:
    
    observer - the CompletableObserver (subclass) to use and return, not null
    
    Returns:
    
    the input observer
    
    Throws:
    
    NullPointerException - if observer is null
    
    Since:
    
    2.0
  - subscribe
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Disposable subscribe(@NonNull Action onComplete,
        @NonNull Consumer<? super Throwable> onError)
```
    Subscribes to this Completable and calls back either the onError or onComplete functions.
    
    Scheduler:
    
    subscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onComplete - the Action that is called if the Completable completes normally
    
    onError - the Consumer that is called if this Completable emits an error
    
    Returns:
    
    the new Disposable that can be used for disposing the subscription at any time
    
    Throws:
    
    NullPointerException - if onComplete or onError is null
    
    See Also:
    
    subscribe(Action, Consumer, DisposableContainer)
  - subscribe
```
@SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable subscribe(@NonNull Action onComplete,
        @NonNull Consumer<? super Throwable> onError,
        @NonNull DisposableContainer container)
```
    Wraps the given onXXX callbacks into a Disposable CompletableObserver, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the CompletableObserver is removed from the given composite.
    The CompletableObserver will be removed after the callback for the terminal event has been invoked.
    
    Scheduler:
    
    subscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onError - the callback for an upstream error
    
    onComplete - the callback for an upstream completion
    
    container - the DisposableContainer (such as CompositeDisposable) to add and remove the created Disposable CompletableObserver
    
    Returns:
    
    the Disposable that allows disposing the particular subscription.
    
    Throws:
    
    NullPointerException - if onComplete, onError or container is null
    
    Since:
    
    3.1.0
  - subscribe
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Disposable subscribe(@NonNull Action onComplete)
```
    Subscribes to this Completable and calls the given Action when this Completable completes normally.
    
    If the Completable emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the global RxJavaPlugins.onError(Throwable) handler.
    
    Scheduler:
    
    subscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onComplete - the Action called when this Completable completes normally
    
    Returns:
    
    the new Disposable that can be used for disposing the subscription at any time
    
    Throws:
    
    NullPointerException - if onComplete is null
    
    See Also:
    
    subscribe(Action, Consumer, DisposableContainer)
  - subscribeOn
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Completable subscribeOn(@NonNull Scheduler scheduler)
```
    Returns a Completable which subscribes the downstream subscriber on the specified scheduler, making sure the subscription side-effects happen on that specific thread of the Scheduler.
    
    Scheduler:
    
    subscribeOn operates on a Scheduler you specify.
    
    Parameters:
    
    scheduler - the Scheduler to subscribe on
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if scheduler is null
  - takeUntil
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable takeUntil(@NonNull CompletableSource other)
```
    Terminates the downstream if this or the other Completable terminates (wins the termination race) while disposing the connection to the losing source.
    
    Scheduler:
    
    takeUntil does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If both this and the other sources signal an error, only one of the errors is signaled to the downstream and the other error is signaled to the global error handler via RxJavaPlugins.onError(Throwable).
    
    History: 2.1.17 - experimental
    
    Parameters:
    
    other - the other completable source to observe for the terminal signals
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if other is null
    
    Since:
    
    2.2
  - timeout
```
@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Completable timeout(long timeout,
        @NonNull TimeUnit unit)
```
    Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time.
    
    Scheduler:
    
    timeout signals the TimeoutException on the computation Scheduler.
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the unit of timeout
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit is null
  - timeout
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="io.reactivex:computation")
public final @NonNull Completable timeout(long timeout,
        @NonNull TimeUnit unit,
        @NonNull CompletableSource fallback)
```
    Returns a Completable that runs this Completable and switches to the other CompletableSource in case this Completable doesn't complete within the given time.
    
    Scheduler:
    
    timeout subscribes to the other CompletableSource on the computation Scheduler.
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the unit of timeout
    
    fallback - the other CompletableSource instance to switch to in case of a timeout
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit or fallback is null
  - timeout
```
@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Completable timeout(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)
```
    Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.
    
    Scheduler:
    
    timeout signals the TimeoutException on the Scheduler you specify.
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the unit of timeout
    
    scheduler - the Scheduler to use to wait for completion and signal TimeoutException
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit or scheduler is null
  - timeout
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Completable timeout(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        @NonNull CompletableSource fallback)
```
    Returns a Completable that runs this Completable and switches to the other CompletableSource in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.
    
    Scheduler:
    
    timeout subscribes to the other CompletableSource on the Scheduler you specify.
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the unit of timeout
    
    scheduler - the Scheduler to use to wait for completion
    
    fallback - the other Completable instance to switch to in case of a timeout
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit, scheduler or fallback is null
  - to
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final <R> R to(@NonNull CompletableConverter<? extends R> converter)
```
    Calls the specified CompletableConverter function during assembly time and returns its resulting value.
    
    This allows fluent conversion to any other type.
    
    Scheduler:
    
    to does not operate by default on a particular Scheduler.
    
    History: 2.1.7 - experimental
    
    Type Parameters:
    
    R - the resulting object type
    
    Parameters:
    
    converter - the CompletableConverter that receives the current Completable instance and returns a value to be the result of to()
    
    Returns:
    
    the converted value
    
    Throws:
    
    NullPointerException - if converter is null
    
    Since:
    
    2.2
  - toFlowable
```
@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @NonNull
public final <T> @NonNull Flowable<T> toFlowable()
```
    Returns a Flowable which when subscribed to subscribes to this Completable and relays the terminal events to the downstream Subscriber.
    
    Backpressure:
    
    The returned Flowable honors the backpressure of the downstream consumer.
    
    Scheduler:
    
    toFlowable does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Returns:
    
    the new Flowable instance
  - toFuture
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Future<Void> toFuture()
```
    Returns a Future representing the termination of the current Completable via a null value.
    
    Cancelling the Future will cancel the subscription to the current Completable.
    
    Scheduler:
    
    toFuture does not operate by default on a particular Scheduler.
    
    Returns:
    
    the new Future instance
    
    Since:
    
    3.0.0
    
    See Also:
    
    ReactiveX documentation: To
  - toMaybe
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <T> @NonNull Maybe<T> toMaybe()
```
    Converts this Completable into a Maybe.
    
    Scheduler:
    
    toMaybe does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Returns:
    
    the new Maybe instance
  - toObservable
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <T> @NonNull Observable<T> toObservable()
```
    Returns an Observable which when subscribed to subscribes to this Completable and relays the terminal events to the downstream Observer.
    
    Scheduler:
    
    toObservable does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Returns:
    
    the new Observable created
  - toSingle
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <T> @NonNull Single<T> toSingle(@NonNull Supplier<? extends T> completionValueSupplier)
```
    Converts this Completable into a Single which when this Completable completes normally, calls the given Supplier and emits its returned value through onSuccess.
    
    Scheduler:
    
    toSingle does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    completionValueSupplier - the value supplier called when this Completable completes normally
    
    Returns:
    
    the new Single instance
    
    Throws:
    
    NullPointerException - if completionValueSupplier is null
  - toSingleDefault
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <T> @NonNull Single<T> toSingleDefault(T completionValue)
```
    Converts this Completable into a Single which when this Completable completes normally, emits the given value through onSuccess.
    
    Scheduler:
    
    toSingleDefault does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    completionValue - the value to emit when this Completable completes normally
    
    Returns:
    
    the new Single instance
    
    Throws:
    
    NullPointerException - if completionValue is null
  - unsubscribeOn
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Completable unsubscribeOn(@NonNull Scheduler scheduler)
```
    Returns a Completable which makes sure when an observer disposes the subscription, the dispose() method is called on the specified Scheduler.
    
    Scheduler:
    
    unsubscribeOn calls dispose() of the upstream on the Scheduler you specify.
    
    Parameters:
    
    scheduler - the target Scheduler where to execute the disposing
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if scheduler is null
  - test
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull TestObserver<Void> test()
```
    Creates a TestObserver and subscribes it to this Completable.
    
    Scheduler:
    
    test does not operate by default on a particular Scheduler.
    
    Returns:
    
    the new TestObserver instance
    
    Since:
    
    2.0
  - test
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull TestObserver<Void> test(boolean dispose)
```
    Creates a TestObserver optionally in cancelled state, then subscribes it to this Completable.
    
    Parameters:
    
    dispose - if true, the TestObserver will be cancelled before subscribing to this Completable.
    
    Scheduler:
    
    test does not operate by default on a particular Scheduler.
    
    Returns:
    
    the new TestObserver instance
    
    Since:
    
    2.0
  - fromCompletionStage
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static @NonNull Completable fromCompletionStage(@NonNull CompletionStage<?> stage)
```
    Signals completion (or error) when the CompletionStage terminates.
    
    Note that the operator takes an already instantiated, running or terminated CompletionStage. If the CompletionStage is to be created per consumer upon subscription, use defer(Supplier) around fromCompletionStage:
```
 Maybe.defer(() -> Completable.fromCompletionStage(createCompletionStage()));
 
```
    Canceling the flow can't cancel the execution of the CompletionStage because CompletionStage itself doesn't support cancellation. Instead, the operator detaches from the CompletionStage.
    
    Scheduler:
    
    fromCompletionStage does not operate by default on a particular Scheduler.
    Parameters:
    
    stage - the CompletionStage to convert to a Completable and signal onComplete or onError when the CompletionStage terminates normally or with a failure
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if stage is null
    
    Since:
    
    3.0.0
  - toCompletionStage
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <T> @NonNull CompletionStage<T> toCompletionStage(T defaultItem)
```
    Signals the given default item when the upstream completes or signals the upstream error via a CompletionStage.
    
    The upstream can be canceled by converting the resulting CompletionStage into CompletableFuture via CompletionStage.toCompletableFuture() and calling CompletableFuture.cancel(boolean) on it. The upstream will be also cancelled if the resulting CompletionStage is converted to and completed manually by CompletableFuture.complete(Object) or CompletableFuture.completeExceptionally(Throwable).
    CompletionStages don't have a notion of emptiness and allow nulls, therefore, one can either use a defaultItem of null or turn the flow into a sequence of Optionals and default to Optional.empty():
```
 CompletionStage<Optional<T>> stage = source.map(Optional::of).toCompletionStage(Optional.empty());
 
```
    Scheduler:
    
    toCompletionStage does not operate by default on a particular Scheduler.
    Type Parameters:
    
    T - the type of the default item to signal upon completion
    
    Parameters:
    
    defaultItem - the item to signal upon completion
    
    Returns:
    
    the new CompletionStage instance
    
    Since:
    
    3.0.0