Completable (RxJava Javadoc 3.0.0-RC4)

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 SingleObserver.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 Completable`	`amb(Iterable<? extends 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.
`static Completable`	`ambArray(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.
`Completable`	`ambWith(CompletableSource other)` Returns a Completable that emits the a terminated event of either this Completable or the other Completable whichever fires first.
`Completable`	`andThen(CompletableSource next)` Returns a Completable that first runs this Completable and then the other completable.
`<T> Maybe<T>`	`andThen(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> Observable<T>`	`andThen(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> Flowable<T>`	`andThen(Publisher<T> next)` Returns a Flowable which will subscribe to this Completable and once that is completed then will subscribe to the `next` Flowable.
`<T> Single<T>`	`andThen(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, 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.
`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 Completable`	`complete()` Returns a Completable instance that completes immediately when subscribed to.
`Completable`	`compose(CompletableTransformer transformer)` Calls the given transformer function with this instance and returns the function's resulting Completable.
`static Completable`	`concat(Iterable<? extends CompletableSource> sources)` Returns a Completable which completes only when all sources complete, one after another.
`static Completable`	`concat(Publisher<? extends CompletableSource> sources)` Returns a Completable which completes only when all sources complete, one after another.
`static Completable`	`concat(Publisher<? extends CompletableSource> sources, int prefetch)` Returns a Completable which completes only when all sources complete, one after another.
`static Completable`	`concatArray(CompletableSource... sources)` Returns a Completable which completes only when all sources complete, one after another.
`Completable`	`concatWith(CompletableSource other)` Concatenates this Completable with another Completable.
`static Completable`	`create(CompletableOnSubscribe source)` Provides an API (via a cold Completable) that bridges the reactive world with the callback-style world.
`static Completable`	`defer(Supplier<? extends CompletableSource> completableSupplier)` Defers the subscription to a Completable instance returned by a supplier.
`Completable`	`delay(long delay, TimeUnit unit)` Returns a Completable which delays the emission of the completion event by the given time.
`Completable`	`delay(long delay, TimeUnit unit, Scheduler scheduler)` Returns a Completable which delays the emission of the completion event by the given time while running on the specified scheduler.
`Completable`	`delay(long delay, TimeUnit unit, 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.
`Completable`	`delaySubscription(long delay, TimeUnit unit)` Returns a Completable that delays the subscription to the source CompletableSource by a given amount of time.
`Completable`	`delaySubscription(long delay, TimeUnit unit, Scheduler scheduler)` Returns a Completable that delays the subscription to the source CompletableSource by a given amount of time, both waiting and subscribing on a given Scheduler.
`Completable`	`doAfterTerminate(Action onAfterTerminate)` Returns a Completable instance that calls the given onTerminate callback after this Completable completes normally or with an exception.
`Completable`	`doFinally(Action onFinally)` Calls the specified action after this Completable signals onError or onComplete or gets disposed by the downstream.
`Completable`	`doOnComplete(Action onComplete)` Returns a Completable which calls the given onComplete callback if this Completable completes.
`Completable`	`doOnDispose(Action onDispose)` Calls the shared `Action` if a CompletableObserver subscribed to the current Completable disposes the common Disposable it received via onSubscribe.
`Completable`	`doOnError(Consumer<? super Throwable> onError)` Returns a Completable which calls the given onError callback if this Completable emits an error.
`Completable`	`doOnEvent(Consumer<? super Throwable> onEvent)` Returns a Completable which calls the given onEvent callback with the (throwable) for an onError or (null) for an onComplete signal from this Completable before delivering said signal to the downstream.
`Completable`	`doOnSubscribe(Consumer<? super Disposable> onSubscribe)` Returns a Completable instance that calls the given onSubscribe callback with the disposable that child subscribers receive on subscription.
`Completable`	`doOnTerminate(Action onTerminate)` Returns a Completable instance that calls the given onTerminate callback just before this Completable completes normally or with an exception.
`static Completable`	`error(Supplier<? extends Throwable> errorSupplier)` Creates a Completable which calls the given error supplier for each subscriber and emits its returned Throwable.
`static Completable`	`error(Throwable error)` Creates a Completable instance that emits the given Throwable exception to subscribers.
`static Completable`	`fromAction(Action run)` Returns a Completable instance that runs the given Action for each subscriber and emits either an unchecked exception or simply completes.
`static Completable`	`fromCallable(Callable<?> callable)` Returns a Completable which when subscribed, executes the callable function, ignores its normal result and emits onError or onComplete only.
`static Completable`	`fromFuture(Future<?> future)` Returns a Completable instance that reacts to the termination of the given Future in a blocking fashion.
`static <T> Completable`	`fromMaybe(MaybeSource<T> maybe)` Returns a Completable instance that when subscribed to, subscribes to the `Maybe` instance and emits a completion event if the maybe emits `onSuccess`/`onComplete` or forwards any `onError` events.
`static <T> Completable`	`fromObservable(ObservableSource<T> observable)` Returns a Completable instance that subscribes to the given Observable, ignores all values and emits only the terminal event.
`static <T> Completable`	`fromPublisher(Publisher<T> publisher)` Returns a Completable instance that subscribes to the given publisher, ignores all values and emits only the terminal event.
`static Completable`	`fromRunnable(Runnable run)` Returns a Completable instance that runs the given Runnable for each subscriber and emits either its exception or simply completes.
`static <T> Completable`	`fromSingle(SingleSource<T> single)` Returns a Completable instance that when subscribed to, subscribes to the Single instance and emits a completion event if the single emits onSuccess or forwards any onError events.
`static Completable`	`fromSupplier(Supplier<?> supplier)` Returns a Completable which when subscribed, executes the supplier function, ignores its normal result and emits onError or onComplete only.
`Completable`	`hide()` Hides the identity of this Completable and its Disposable.
`Completable`	`lift(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> 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 Completable`	`merge(Iterable<? extends CompletableSource> sources)` Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
`static Completable`	`merge(Publisher<? extends CompletableSource> sources)` Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
`static Completable`	`merge(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 Completables complete or one of them emits an error.
`static Completable`	`mergeArray(CompletableSource... sources)` Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
`static Completable`	`mergeArrayDelayError(CompletableSource... sources)` Returns a CompletableConsumable that subscribes to all Completables in the source array and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
`static Completable`	`mergeDelayError(Iterable<? extends CompletableSource> sources)` Returns a Completable that subscribes to all Completables in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
`static Completable`	`mergeDelayError(Publisher<? extends CompletableSource> sources)` Returns a Completable that subscribes to all Completables in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
`static Completable`	`mergeDelayError(Publisher<? extends CompletableSource> sources, int maxConcurrency)` Returns a Completable that subscribes to a limited number of inner Completables at once in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
`Completable`	`mergeWith(CompletableSource other)` Returns a Completable which subscribes to this and the other Completable and completes when both of them complete or one emits an error.
`static Completable`	`never()` Returns a Completable that never calls onError or onComplete.
`Completable`	`observeOn(Scheduler scheduler)` Returns a Completable which emits the terminal events from the thread of the specified scheduler.
`Completable`	`onErrorComplete()` Returns a Completable instance that if this Completable emits an error, it will emit an onComplete and swallow the throwable.
`Completable`	`onErrorComplete(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.
`Completable`	`onErrorResumeNext(Function<? super Throwable,? extends CompletableSource> errorMapper)` Returns a Completable instance that when encounters an error from this Completable, calls the specified mapper function that returns another Completable instance for it and resumes the execution with it.
`Completable`	`onTerminateDetach()` Nulls out references to the upstream producer and downstream CompletableObserver if the sequence is terminated or downstream calls dispose().
`Completable`	`repeat()` Returns a Completable that repeatedly subscribes to this Completable until disposed.
`Completable`	`repeat(long times)` Returns a Completable that subscribes repeatedly at most the given times to this Completable.
`Completable`	`repeatUntil(BooleanSupplier stop)` Returns a Completable that repeatedly subscribes to this Completable so long as the given stop supplier returns false.
`Completable`	`repeatWhen(Function<? super Flowable<Object>,? extends Publisher<?>> handler)` Returns a Completable instance that repeats when the Publisher returned by the handler emits an item or completes when this Publisher emits a completed event.
`Completable`	`retry()` Returns a Completable that retries this Completable as long as it emits an onError event.
`Completable`	`retry(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.
`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.
`Completable`	`retry(long times, 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.
`Completable`	`retry(Predicate<? super Throwable> predicate)` Returns a Completable that when this Completable emits an error, calls the given predicate with the latest exception to decide whether to resubscribe to this or not.
`Completable`	`retryWhen(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.
`Completable`	`startWith(CompletableSource other)` Returns a Completable which first runs the other Completable then this completable if the other completed normally.
`<T> Observable<T>`	`startWith(Observable<T> other)` Returns an Observable which first delivers the events of the other Observable then runs this CompletableConsumable.
`<T> Flowable<T>`	`startWith(Publisher<T> other)` Returns a Flowable which first delivers the events of the other Publisher then runs this Completable.
`Disposable`	`subscribe()` Subscribes to this CompletableConsumable and returns a Disposable which can be used to dispose the subscription.
`Disposable`	`subscribe(Action onComplete)` Subscribes to this Completable and calls the given Action when this Completable completes normally.
`Disposable`	`subscribe(Action onComplete, Consumer<? super Throwable> onError)` Subscribes to this Completable and calls back either the onError or onComplete functions.
`void`	`subscribe(CompletableObserver observer)` Subscribes the given CompletableObserver to this CompletableSource instance.
`protected abstract void`	`subscribeActual(CompletableObserver observer)` Implement this method to handle the incoming `CompletableObserver`s and perform the business logic in your operator.
`Completable`	`subscribeOn(Scheduler scheduler)` Returns a Completable which subscribes the child 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.
`Completable`	`takeUntil(CompletableSource other)` Terminates the downstream if this or the other `Completable` terminates (wins the termination race) while disposing the connection to the losing source.
`TestObserver<Void>`	`test()` Creates a TestObserver and subscribes it to this Completable.
`TestObserver<Void>`	`test(boolean dispose)` Creates a TestObserver optionally in cancelled state, then subscribes it to this Completable.
`Completable`	`timeout(long timeout, TimeUnit unit)` Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time.
`Completable`	`timeout(long timeout, TimeUnit unit, CompletableSource other)` Returns a Completable that runs this Completable and switches to the other Completable in case this Completable doesn't complete within the given time.
`Completable`	`timeout(long timeout, TimeUnit unit, 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.
`Completable`	`timeout(long timeout, TimeUnit unit, Scheduler scheduler, CompletableSource other)` Returns a Completable that runs this Completable and switches to the other Completable in case this Completable doesn't complete within the given time while "waiting" on the specified scheduler.
`static Completable`	`timer(long delay, TimeUnit unit)` Returns a Completable instance that fires its onComplete event after the given delay elapsed.
`static Completable`	`timer(long delay, TimeUnit unit, Scheduler scheduler)` Returns a Completable instance that fires its onComplete event after the given delay elapsed by using the supplied scheduler.
`<R> R`	`to(CompletableConverter<? extends R> converter)` Calls the specified converter function during assembly time and returns its resulting value.
`<T> Flowable<T>`	`toFlowable()` Returns a Flowable which when subscribed to subscribes to this Completable and relays the terminal events to the subscriber.
`<T> Maybe<T>`	`toMaybe()` Converts this Completable into a `Maybe`.
`<T> Observable<T>`	`toObservable()` Returns an Observable which when subscribed to subscribes to this Completable and relays the terminal events to the subscriber.
`<T> Single<T>`	`toSingle(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> Single<T>`	`toSingleDefault(T completionValue)` Converts this Completable into a Single which when this Completable completes normally, emits the given value through onSuccess.
`static Completable`	`unsafeCreate(CompletableSource source)` Constructs a Completable instance by wrapping the given source callback without any safeguards; you should manage the lifecycle and response to downstream disposal.
`Completable`	`unsubscribeOn(Scheduler scheduler)` Returns a Completable which makes sure when a subscriber disposes the subscription, the dispose is called on the specified scheduler.
`static <R> Completable`	`using(Supplier<R> resourceSupplier, Function<? super R,? extends CompletableSource> completableFunction, Consumer<? super R> disposer)` Returns a Completable instance which manages a resource along with a custom Completable instance while the subscription is active.
`static <R> Completable`	`using(Supplier<R> resourceSupplier, Function<? super R,? extends CompletableSource> completableFunction, Consumer<? super R> disposer, boolean eager)` Returns a Completable instance which manages a resource along with a custom Completable instance while the subscription is active and performs eager or lazy resource disposition.
`static Completable`	`wrap(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")
public static Completable ambArray(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 Completable amb(Iterable<? extends 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:
    
    amb 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 Iterable.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - complete
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable complete()
```
    Returns a Completable instance that completes immediately when subscribed to.
    
    Scheduler:
    
    complete does not operate by default on a particular Scheduler.
    
    Returns:
    
    a Completable instance that completes immediately
  - concatArray
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable concatArray(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 Completable instance which completes only when all sources complete
    
    Throws:
    
    NullPointerException - if sources is null
  - concat
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable concat(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 Completable instance which completes only when all sources complete
    
    Throws:
    
    NullPointerException - if sources is null
  - concat
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static Completable concat(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 Completable instance which completes only when all sources complete
    
    Throws:
    
    NullPointerException - if sources is null
  - concat
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static Completable concat(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 Completable instance which completes only when all sources complete
    
    Throws:
    
    NullPointerException - if sources is null
  - create
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable create(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
    
    See Also:
    
    CompletableOnSubscribe, Cancellable
  - unsafeCreate
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable unsafeCreate(CompletableSource source)
```
    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:
    
    source - the callback which will receive the CompletableObserver instances when the Completable is subscribed to.
    
    Returns:
    
    the created Completable instance
    
    Throws:
    
    NullPointerException - if source is null
  - defer
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable defer(Supplier<? extends CompletableSource> completableSupplier)
```
    Defers the subscription to a Completable instance returned by a supplier.
    
    Scheduler:
    
    defer does not operate by default on a particular Scheduler.
    
    Parameters:
    
    completableSupplier - the supplier that returns the Completable that will be subscribed to.
    
    Returns:
    
    the Completable instance
  - error
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable error(Supplier<? extends Throwable> errorSupplier)
```
    Creates a Completable which calls the given error supplier for each subscriber and emits its returned Throwable.
    
    If the errorSupplier returns null, the child CompletableObservers will receive a NullPointerException.
    
    Scheduler:
    
    error does not operate by default on a particular Scheduler.
    
    Parameters:
    
    errorSupplier - the error supplier, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if errorSupplier is null
  - error
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable error(Throwable error)
```
    Creates a Completable instance that emits the given Throwable exception to subscribers.
    
    Scheduler:
    
    error does not operate by default on a particular Scheduler.
    
    Parameters:
    
    error - the Throwable instance to emit, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if error is null
  - fromAction
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable fromAction(Action run)
```
    Returns a Completable instance that runs the given Action for each subscriber and emits either an unchecked 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:
    
    run - the runnable to run for each subscriber
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if run is null
  - fromCallable
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable fromCallable(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 subscriber
    
    Returns:
    
    the new Completable instance
    
    See Also:
    
    defer(Supplier), fromSupplier(Supplier)
  - fromFuture
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable fromFuture(Future<?> future)
```
    Returns a Completable instance that reacts to the termination of the given Future in a blocking fashion.
    
    Note that if any of the observers to this Completable call dispose, this Completable will cancel the future.
    
    Scheduler:
    
    fromFuture does not operate by default on a particular Scheduler.
    
    Parameters:
    
    future - the future to react to
    
    Returns:
    
    the new Completable instance
  - fromMaybe
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> Completable fromMaybe(MaybeSource<T> maybe)
```
    Returns a Completable instance that when subscribed to, subscribes to the Maybe instance and emits a completion 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 Maybe instance to subscribe to, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if single is null
    
    Since:
    
    2.2
  - fromRunnable
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable fromRunnable(Runnable run)
```
    Returns a Completable instance that runs the given Runnable for each subscriber and emits either its exception or simply completes.
    
    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 subscriber
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if run is null
  - fromObservable
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> Completable fromObservable(ObservableSource<T> observable)
```
    Returns a Completable instance that subscribes to the given Observable, 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 Observable
    
    Parameters:
    
    observable - the Observable instance to subscribe to, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if flowable is null
  - fromPublisher
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public static <T> Completable fromPublisher(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> Completable fromSingle(SingleSource<T> single)
```
    Returns a Completable instance that when subscribed to, subscribes to the Single 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 Single
    
    Parameters:
    
    single - the Single 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 Completable fromSupplier(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 subscriber
    
    Returns:
    
    the new Completable instance
    
    Since:
    
    3.0.0
    
    See Also:
    
    defer(Supplier), fromCallable(Callable)
  - mergeArray
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable mergeArray(CompletableSource... sources)
```
    Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables 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 iterable sequence of sources.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    See Also:
    
    mergeArrayDelayError(CompletableSource...)
  - merge
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable merge(Iterable<? extends CompletableSource> sources)
```
    Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables 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 sources.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    See Also:
    
    mergeDelayError(Iterable)
  - merge
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=UNBOUNDED_IN)
public static Completable merge(Publisher<? extends CompletableSource> sources)
```
    Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
    
    Backpressure:
    
    The returned Completable honors the backpressure of the downstream consumer and expects the other Publisher to honor it as well.
    
    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 iterable sequence of sources.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
    
    See Also:
    
    mergeDelayError(Publisher)
  - merge
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static Completable merge(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 Completables complete or one of them emits an error.
    
    Backpressure:
    
    The returned Completable honors the backpressure of the downstream consumer and expects the other Publisher to honor it as well.
    
    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 iterable sequence of sources.
    
    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")
public static Completable mergeArrayDelayError(CompletableSource... sources)
```
    Returns a CompletableConsumable that subscribes to all Completables in the source array and delays any error emitted by either the sources observable or any of the inner Completables 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 Completables
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - mergeDelayError
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable mergeDelayError(Iterable<? extends CompletableSource> sources)
```
    Returns a Completable that subscribes to all Completables in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables 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 Completables
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - mergeDelayError
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=UNBOUNDED_IN)
public static Completable mergeDelayError(Publisher<? extends CompletableSource> sources)
```
    Returns a Completable that subscribes to all Completables in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
    
    Backpressure:
    
    The returned Completable honors the backpressure of the downstream consumer and expects the other Publisher to honor it as well.
    
    Scheduler:
    
    mergeDelayError does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sequence of Completables
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - mergeDelayError
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static Completable mergeDelayError(Publisher<? extends CompletableSource> sources,
        int maxConcurrency)
```
    Returns a Completable that subscribes to a limited number of inner Completables at once in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
    
    Backpressure:
    
    The returned Completable honors the backpressure of the downstream consumer and expects the other Publisher to honor it as well.
    
    Scheduler:
    
    mergeDelayError does not operate by default on a particular Scheduler.
    
    Parameters:
    
    sources - the sequence of Completables
    
    maxConcurrency - the maximum number of concurrent subscriptions to Completables
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - never
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public static 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")
public static Completable timer(long delay,
        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
  - timer
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public static Completable timer(long delay,
        TimeUnit unit,
        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 complete event
    
    Returns:
    
    the new Completable instance
  - using
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public static <R> Completable using(Supplier<R> resourceSupplier,
        Function<? super R,? extends CompletableSource> completableFunction,
        Consumer<? super R> disposer)
```
    Returns a Completable instance which manages a resource along with a custom Completable 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.
    
    completableFunction - the function that given a resource returns a Completable instance that will be subscribed to
    
    disposer - the consumer that disposes the resource created by the resource supplier
    
    Returns:
    
    the new Completable instance
  - using
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <R> Completable using(Supplier<R> resourceSupplier,
        Function<? super R,? extends CompletableSource> completableFunction,
        Consumer<? super R> disposer,
        boolean eager)
```
    Returns a Completable instance which manages a resource along with a custom Completable 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. Exceptions thrown at this time will be delivered to RxJavaPlugins 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
    
    completableFunction - the function that given a resource returns a non-null Completable instance that will be subscribed to
    
    disposer - 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
  - wrap
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static Completable wrap(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 source or its wrapper Completable
    
    Throws:
    
    NullPointerException - if source is null
  - ambWith
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final Completable ambWith(CompletableSource other)
```
    Returns a Completable that emits the a terminated event of either this Completable or the other Completable whichever fires first.
    
    Scheduler:
    
    ambWith does not operate by default on a particular Scheduler.
    
    Parameters:
    
    other - the other Completable, 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> Observable<T> andThen(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 subscriber and will result in skipping the subscription of the Observable.
    
    Scheduler:
    
    andThen does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type of the next ObservableSource
    
    Parameters:
    
    next - the Observable to subscribe after this Completable is completed, not null
    
    Returns:
    
    Observable that composes this Completable and next
    
    Throws:
    
    NullPointerException - if next is null
  - andThen
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <T> Flowable<T> andThen(Publisher<T> next)
```
    Returns a Flowable which will subscribe to this Completable and once that is completed then will subscribe to the next Flowable. An error event from this Completable will be propagated to the downstream subscriber and will result in skipping the subscription of the 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:
    
    Flowable that composes this Completable and next
    
    Throws:
    
    NullPointerException - if next is null
  - andThen
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <T> Single<T> andThen(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 subscriber and will result in skipping the subscription of the Single.
    
    Scheduler:
    
    andThen does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type of the next SingleSource
    
    Parameters:
    
    next - the Single to subscribe after this Completable is completed, not null
    
    Returns:
    
    Single that composes this Completable and next
  - andThen
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <T> Maybe<T> andThen(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 subscriber and will result in skipping the subscription of the Maybe.
    
    Scheduler:
    
    andThen does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type of the next MaybeSource
    
    Parameters:
    
    next - the Maybe to subscribe after this Completable is completed, not null
    
    Returns:
    
    Maybe that composes this Completable and next
  - andThen
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable andThen(CompletableSource next)
```
    Returns a Completable that first runs this Completable and then the other completable.
    
    This is an alias for concatWith(CompletableSource).
    
    Scheduler:
    
    andThen does not operate by default on a particular Scheduler.
    
    Parameters:
    
    next - the other Completable, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if other 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
 @NonNull
 @SchedulerSupport(value="none")
public final boolean blockingAwait(long timeout,
        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
  - cache
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final 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")
public final Completable compose(CompletableTransformer transformer)
```
    Calls the given transformer function with this instance and returns the function's resulting Completable.
    
    Scheduler:
    
    compose does not operate by default on a particular Scheduler.
    
    Parameters:
    
    transformer - the transformer function, not null
    
    Returns:
    
    the Completable returned by the function
    
    Throws:
    
    NullPointerException - if transformer is null
  - concatWith
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final Completable concatWith(CompletableSource other)
```
    Concatenates this Completable with another Completable.
    
    Scheduler:
    
    concatWith does not operate by default on a particular Scheduler.
    
    Parameters:
    
    other - the other Completable, not null
    
    Returns:
    
    the new Completable which subscribes to this and then the other Completable
    
    Throws:
    
    NullPointerException - if other is null
    
    See Also:
    
    andThen(MaybeSource), andThen(ObservableSource), andThen(SingleSource), andThen(Publisher)
  - delay
```
@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
public final Completable delay(long delay,
        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:
    
    delay - the delay time
    
    unit - the delay unit
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit is null
  - delay
```
@CheckReturnValue
 @SchedulerSupport(value="custom")
public final Completable delay(long delay,
        TimeUnit unit,
        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:
    
    delay - 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 Completable delay(long delay,
        TimeUnit unit,
        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:
    
    delay - 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")
public final Completable delaySubscription(long delay,
        TimeUnit unit)
```
    Returns a Completable that delays the subscription to the source CompletableSource by a given amount of time.
    
    Scheduler:
    
    This version of delaySubscription operates by default on the computation Scheduler.
    
    History: 2.2.3 - experimental
    
    Parameters:
    
    delay - the time to delay the subscription
    
    unit - the time unit of delay
    
    Returns:
    
    a Completable that delays the subscription to the source CompletableSource by the given amount
    
    Since:
    
    3.0.0
    
    See Also:
    
    ReactiveX operators documentation: Delay
  - delaySubscription
```
@CheckReturnValue
 @SchedulerSupport(value="custom")
public final Completable delaySubscription(long delay,
        TimeUnit unit,
        Scheduler scheduler)
```
    Returns a Completable that delays the subscription to the source CompletableSource 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:
    
    delay - the time to delay the subscription
    
    unit - the time unit of delay
    
    scheduler - the Scheduler on which the waiting and subscription will happen
    
    Returns:
    
    a Completable that delays the subscription to the source CompletableSource by a given amount, waiting and subscribing on the given Scheduler
    
    Since:
    
    3.0.0
    
    See Also:
    
    ReactiveX operators documentation: Delay
  - doOnComplete
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable doOnComplete(Action onComplete)
```
    Returns a Completable which calls the given onComplete callback if this Completable completes.
    
    Scheduler:
    
    doOnComplete does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onComplete - the callback 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")
public final Completable doOnDispose(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 child subscriber disposes the subscription
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onDispose is null
  - doOnError
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable doOnError(Consumer<? super Throwable> onError)
```
    Returns a Completable which calls the given onError callback if this Completable emits an error.
    
    Scheduler:
    
    doOnError does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onError - the error callback
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onError is null
    
    See Also:
    
    doFinally(Action)
  - doOnEvent
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final Completable doOnEvent(Consumer<? super Throwable> onEvent)
```
    Returns a Completable which calls the given onEvent callback with the (throwable) for an onError or (null) for an onComplete signal from this Completable before delivering said signal to the downstream.
    
    Scheduler:
    
    doOnEvent does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onEvent - the event callback
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onEvent is null
  - doOnSubscribe
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable doOnSubscribe(Consumer<? super Disposable> onSubscribe)
```
    Returns a Completable instance that calls the given onSubscribe callback with the disposable that child subscribers receive on subscription.
    
    Scheduler:
    
    doOnSubscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onSubscribe - the callback called when a child subscriber subscribes
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if onSubscribe is null
  - doOnTerminate
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable doOnTerminate(Action onTerminate)
```
    Returns a Completable instance that calls the given onTerminate callback just before this Completable completes normally or with an exception.
    
    Scheduler:
    
    doOnTerminate does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onTerminate - the callback to call just before this Completable terminates
    
    Returns:
    
    the new Completable instance
    
    See Also:
    
    doFinally(Action)
  - doAfterTerminate
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable doAfterTerminate(Action onAfterTerminate)
```
    Returns a Completable instance that calls the given onTerminate callback after this Completable completes normally or with an exception.
    
    Scheduler:
    
    doAfterTerminate does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onAfterTerminate - the callback to call after this Completable terminates
    
    Returns:
    
    the new Completable instance
    
    See Also:
    
    doFinally(Action)
  - doFinally
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final Completable doFinally(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
    
    Since:
    
    2.1
  - lift
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final Completable lift(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 upstream 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
    
    See Also:
    
    RxJava wiki: Writing operators, compose(CompletableTransformer)
  - materialize
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final <T> 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 Completable mergeWith(CompletableSource other)
```
    Returns a Completable which subscribes to this and the other Completable 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 Completable instance
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if other is null
  - observeOn
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final Completable observeOn(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")
public final Completable onErrorComplete()
```
    Returns a Completable instance that if this Completable emits an error, it will emit an onComplete and swallow the 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 Completable onErrorComplete(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 an Throwable is emitted which should return true if the Throwable should be swallowed and replaced with an onComplete.
    
    Returns:
    
    the new Completable instance
  - onErrorResumeNext
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final Completable onErrorResumeNext(Function<? super Throwable,? extends CompletableSource> errorMapper)
```
    Returns a Completable instance that when encounters an error from this Completable, calls the specified mapper function that returns another Completable instance for it and resumes the execution with it.
    
    Scheduler:
    
    onErrorResumeNext does not operate by default on a particular Scheduler.
    
    Parameters:
    
    errorMapper - the mapper function that takes the error and should return a Completable as continuation.
    
    Returns:
    
    the new Completable instance
  - onTerminateDetach
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final 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:
    
    a Completable which nulls out references to the upstream producer and downstream CompletableObserver if the sequence is terminated or downstream calls dispose()
    
    Since:
    
    2.2
  - repeat
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final 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")
public final Completable repeat(long times)
```
    Returns a Completable that subscribes repeatedly at most the given times to this Completable.
    
    Scheduler:
    
    repeat does not operate by default on a particular Scheduler.
    
    Parameters:
    
    times - the number of times the resubscription should happen
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    IllegalArgumentException - if times is less than zero
  - repeatUntil
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable repeatUntil(BooleanSupplier stop)
```
    Returns a Completable that repeatedly subscribes to this Completable so long as the given stop supplier returns false.
    
    Scheduler:
    
    repeatUntil does not operate by default on a particular Scheduler.
    
    Parameters:
    
    stop - the supplier that should return true to stop resubscribing.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if stop is null
  - repeatWhen
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable repeatWhen(Function<? super Flowable<Object>,? extends Publisher<?>> handler)
```
    Returns a Completable instance that repeats when the Publisher returned by the handler emits an item or completes when this Publisher emits a completed 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 stop is null
  - retry
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final 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")
public final Completable retry(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 emits an error with the repeat count and the latest exception and should return true to retry.
    
    Returns:
    
    the new Completable instance
  - retry
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final 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")
public final Completable retry(long times,
        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")
public final Completable retry(Predicate<? super Throwable> predicate)
```
    Returns a Completable that when this Completable emits an error, calls the given predicate with the latest exception to decide whether to resubscribe to this 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
  - retryWhen
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable retryWhen(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, signalling 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 handler 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
  - startWith
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final Completable startWith(CompletableSource other)
```
    Returns a Completable which first runs the other Completable then this completable if the other completed normally.
    
    Scheduler:
    
    startWith does not operate by default on a particular Scheduler.
    
    Parameters:
    
    other - the other completable to run first
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if other is null
  - startWith
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <T> Observable<T> startWith(Observable<T> other)
```
    Returns an Observable which first delivers the events of the other Observable then runs this CompletableConsumable.
    
    Scheduler:
    
    startWith does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    other - the other Observable 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> Flowable<T> startWith(Publisher<T> other)
```
    Returns a Flowable which first delivers the events of the other Publisher then runs this 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")
public final 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")
public final Disposable subscribe()
```
    Subscribes to this CompletableConsumable 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 Disposable that allows disposing the subscription
  - subscribe
```
@SchedulerSupport(value="none")
public final void subscribe(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(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")
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 Disposable subscribe(Action onComplete,
        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 runnable that is called if the Completable completes normally
    
    onError - the consumer that is called if this Completable emits an error
    
    Returns:
    
    the Disposable that can be used for disposing the subscription asynchronously
    
    Throws:
    
    NullPointerException - if either callback is null
  - subscribe
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final Disposable subscribe(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 RxJavaPlugins.onError handler.
    
    Scheduler:
    
    subscribe does not operate by default on a particular Scheduler.
    
    Parameters:
    
    onComplete - the runnable called when this Completable completes normally
    
    Returns:
    
    the Disposable that allows disposing the subscription
  - subscribeOn
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final Completable subscribeOn(Scheduler scheduler)
```
    Returns a Completable which subscribes the child 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 Completable takeUntil(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
    
    Since:
    
    2.2
  - timeout
```
@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
public final Completable timeout(long timeout,
        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 timeout unit
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit is null
  - timeout
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="io.reactivex:computation")
public final Completable timeout(long timeout,
        TimeUnit unit,
        CompletableSource other)
```
    Returns a Completable that runs this Completable and switches to the other Completable 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 timeout unit
    
    other - the other Completable instance to switch to in case of a timeout
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit or other is null
  - timeout
```
@CheckReturnValue
 @SchedulerSupport(value="custom")
public final Completable timeout(long timeout,
        TimeUnit unit,
        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 timeout unit
    
    scheduler - the scheduler to use to wait for completion
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit or scheduler is null
  - timeout
```
@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final Completable timeout(long timeout,
        TimeUnit unit,
        Scheduler scheduler,
        CompletableSource other)
```
    Returns a Completable that runs this Completable and switches to the other Completable 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 timeout unit
    
    scheduler - the scheduler to use to wait for completion
    
    other - the other Completable instance to switch to in case of a timeout
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    NullPointerException - if unit, scheduler or other is null
  - to
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final <R> R to(@NonNull CompletableConverter<? extends R> converter)
```
    Calls the specified converter 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 function that receives the current Completable instance and returns a value
    
    Returns:
    
    the converted value
    
    Throws:
    
    NullPointerException - if converter is null
    
    Since:
    
    2.2
  - toFlowable
```
@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <T> Flowable<T> toFlowable()
```
    Returns a Flowable which when subscribed to subscribes to this Completable and relays the terminal events to the 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
  - toMaybe
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final <T> 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:
    
    a Maybe that only calls onComplete or onError, based on which one is called by the source Completable.
  - toObservable
```
@CheckReturnValue
 @SchedulerSupport(value="none")
public final <T> Observable<T> toObservable()
```
    Returns an Observable which when subscribed to subscribes to this Completable and relays the terminal events to the subscriber.
    
    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> Single<T> toSingle(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> 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 Completable unsubscribeOn(Scheduler scheduler)
```
    Returns a Completable which makes sure when a subscriber disposes the subscription, the dispose 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")
public final 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")
public final 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