Uses of Class reactor.core.publisher.Mono (Reactor Core 3.5.21 API)

Packages that use Mono
Package	Description
reactor.core.publisher	Provide main Reactive APIs in `Flux` and `Mono`, as well as various helper classes, interfaces used in the composition API, variants of Flux and operator-building utilities.
reactor.core.scheduler	`Scheduler` contract and static registry and factory methods in `Schedulers`.
reactor.test.publisher	Components supporting the creation of test-oriented `Publishers`.
reactor.util.retry

Uses of Mono in reactor.core.publisher

Subclasses of Mono in reactor.core.publisher
Modifier and Type	Class and Description
`class`	`MonoOperator<I,O>` A decorating `Mono` `Publisher` that exposes `Mono` API over an arbitrary `Publisher` Useful to create operators which return a `Mono`.
`class`	`MonoProcessor<O>` Deprecated. Processors will be removed in 3.5. Prefer using `Sinks.One` or `Sinks.Empty` instead, or see https://github.com/reactor/reactor-core/issues/2431 for alternatives

Fields in reactor.core.publisher declared as Mono
Modifier and Type	Field and Description
`protected Mono<? extends I>`	MonoOperator.`source`

Methods in reactor.core.publisher that return Mono
Modifier and Type	Method and Description
`Mono<Boolean>`	Flux.`all(Predicate<? super T> predicate)` Emit a single boolean true if all values of this sequence match the `Predicate`.
`Mono<Void>`	Mono.`and(Publisher<?> other)` Join the termination signals from this mono and another source into the returned void mono
`Mono<Boolean>`	Flux.`any(Predicate<? super T> predicate)` Emit a single boolean true if any of the values of this `Flux` sequence match the predicate.
`Mono<T>`	Sinks.Empty.`asMono()` Return a `Mono` view of this sink.
`Mono<T>`	Mono.`cache()` Turn this `Mono` into a hot source and cache last emitted signals for further `Subscriber`.
`Mono<T>`	Mono.`cache(Duration ttl)` Turn this `Mono` into a hot source and cache last emitted signals for further `Subscriber`, with an expiry timeout.
`Mono<T>`	Mono.`cache(Duration ttl, Scheduler timer)` Turn this `Mono` into a hot source and cache last emitted signals for further `Subscriber`, with an expiry timeout.
`Mono<T>`	Mono.`cache(Function<? super T,Duration> ttlForValue, Function<Throwable,Duration> ttlForError, Supplier<Duration> ttlForEmpty)` Turn this `Mono` into a hot source and cache last emitted signal for further `Subscriber`, with an expiry timeout (TTL) that depends on said signal.
`Mono<T>`	Mono.`cache(Function<? super T,Duration> ttlForValue, Function<Throwable,Duration> ttlForError, Supplier<Duration> ttlForEmpty, Scheduler timer)` Turn this `Mono` into a hot source and cache last emitted signal for further `Subscriber`, with an expiry timeout (TTL) that depends on said signal.
`Mono<T>`	Mono.`cacheInvalidateIf(Predicate<? super T> invalidationPredicate)` Cache `onNext` signal received from the source and replay it to other subscribers, while allowing invalidation by verifying the cached value against the given `Predicate` each time a late subscription occurs.
`Mono<T>`	Mono.`cacheInvalidateWhen(Function<? super T,Mono<Void>> invalidationTriggerGenerator)` Cache `onNext` signal received from the source and replay it to other subscribers, while allowing invalidation via a `Mono<Void>` companion trigger generated from the currently cached value.
`Mono<T>`	Mono.`cacheInvalidateWhen(Function<? super T,Mono<Void>> invalidationTriggerGenerator, Consumer<? super T> onInvalidate)` Cache `onNext` signal received from the source and replay it to other subscribers, while allowing invalidation via a `Mono<Void>` companion trigger generated from the currently cached value.
`Mono<T>`	Mono.`cancelOn(Scheduler scheduler)` Prepare this `Mono` so that subscribers will cancel from it on a specified `Scheduler`.
`<E> Mono<E>`	Mono.`cast(Class<E> clazz)` Cast the current `Mono` produced type into a target produced type.
`Mono<T>`	Mono.`checkpoint()` Activate traceback (full assembly tracing) for this particular `Mono`, in case of an error upstream of the checkpoint.
`Mono<T>`	Mono.`checkpoint(String description)` Activate traceback (assembly marker) for this particular `Mono` by giving it a description that will be reflected in the assembly traceback in case of an error upstream of the checkpoint.
`Mono<T>`	Mono.`checkpoint(String description, boolean forceStackTrace)` Activate traceback (full assembly tracing or the lighter assembly marking depending on the `forceStackTrace` option).
`<R,A> Mono<R>`	Flux.`collect(Collector<? super T,A,? extends R> collector)` Collect all elements emitted by this `Flux` into a container, by applying a Java 8 Stream API `Collector` The collected result will be emitted when this sequence completes, emitting the empty container if the sequence was empty.
`<E> Mono<E>`	Flux.`collect(Supplier<E> containerSupplier, BiConsumer<E,? super T> collector)` Collect all elements emitted by this `Flux` into a user-defined container, by applying a collector `BiConsumer` taking the container and each element.
`Mono<List<T>>`	Flux.`collectList()` Collect all elements emitted by this `Flux` into a `List` that is emitted by the resulting `Mono` when this sequence completes, emitting the empty `List` if the sequence was empty.
`<K> Mono<Map<K,T>>`	Flux.`collectMap(Function<? super T,? extends K> keyExtractor)` Collect all elements emitted by this `Flux` into a hashed `Map` that is emitted by the resulting `Mono` when this sequence completes, emitting the empty `Map` if the sequence was empty.
`<K,V> Mono<Map<K,V>>`	Flux.`collectMap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueExtractor)` Collect all elements emitted by this `Flux` into a hashed `Map` that is emitted by the resulting `Mono` when this sequence completes, emitting the empty `Map` if the sequence was empty.
`<K,V> Mono<Map<K,V>>`	Flux.`collectMap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueExtractor, Supplier<Map<K,V>> mapSupplier)` Collect all elements emitted by this `Flux` into a user-defined `Map` that is emitted by the resulting `Mono` when this sequence completes, emitting the empty `Map` if the sequence was empty.
`<K> Mono<Map<K,Collection<T>>>`	Flux.`collectMultimap(Function<? super T,? extends K> keyExtractor)` Collect all elements emitted by this `Flux` into a `multimap` that is emitted by the resulting `Mono` when this sequence completes, emitting the empty `multimap` if the sequence was empty.
`<K,V> Mono<Map<K,Collection<V>>>`	Flux.`collectMultimap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueExtractor)` Collect all elements emitted by this `Flux` into a `multimap` that is emitted by the resulting `Mono` when this sequence completes, emitting the empty `multimap` if the sequence was empty.
`<K,V> Mono<Map<K,Collection<V>>>`	Flux.`collectMultimap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueExtractor, Supplier<Map<K,Collection<V>>> mapSupplier)` Collect all elements emitted by this `Flux` into a user-defined `multimap` that is emitted by the resulting `Mono` when this sequence completes, emitting the empty `multimap` if the sequence was empty.
`Mono<List<T>>`	Flux.`collectSortedList()` Collect all elements emitted by this `Flux` until this sequence completes, and then sort them in natural order into a `List` that is emitted by the resulting `Mono`.
`Mono<List<T>>`	Flux.`collectSortedList(Comparator<? super T> comparator)` Collect all elements emitted by this `Flux` until this sequence completes, and then sort them using a `Comparator` into a `List` that is emitted by the resulting `Mono`.
`Mono<List<T>>`	ParallelFlux.`collectSortedList(Comparator<? super T> comparator)` Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
`Mono<List<T>>`	ParallelFlux.`collectSortedList(Comparator<? super T> comparator, int capacityHint)` Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
`Mono<T>`	Mono.`contextCapture()` If context-propagation library is on the classpath, this is a convenience shortcut to capture thread local values during the subscription phase and put them in the `Context` that is visible upstream of this operator.
`Mono<T>`	Mono.`contextWrite(ContextView contextToAppend)` Enrich the `Context` visible from downstream for the benefit of upstream operators, by making all values from the provided `ContextView` visible on top of pairs from downstream.
`Mono<T>`	Mono.`contextWrite(Function<Context,Context> contextModifier)` Enrich the `Context` visible from downstream for the benefit of upstream operators, by applying a `Function` to the downstream `Context`.
`static <T> Mono<T>`	Hooks.`convertToMonoBypassingHooks(Publisher<T> publisher, boolean enforceMonoContract)` Utility method to convert a `Publisher` to a `Mono` without applying `Hooks`.
`Mono<Long>`	Flux.`count()` Counts the number of values in this `Flux`.
`static <T> Mono<T>`	Mono.`create(Consumer<MonoSink<T>> callback)` Creates a deferred emitter that can be used with callback-based APIs to signal at most one value, a complete or an error signal.
`Mono<T>`	Mono.`defaultIfEmpty(T defaultV)` Provide a default single value if this mono is completed without any data
`static <T> Mono<T>`	Mono.`defer(Supplier<? extends Mono<? extends T>> supplier)` Create a `Mono` provider that will `supply` a target `Mono` to subscribe to for each `Subscriber` downstream.
`static <T> Mono<T>`	Mono.`deferContextual(Function<ContextView,? extends Mono<? extends T>> contextualMonoFactory)` Create a `Mono` provider that will `supply` a target `Mono` to subscribe to for each `Subscriber` downstream.
`static Mono<Long>`	Mono.`delay(Duration duration)` Create a Mono which delays an onNext signal by a given `duration` on a default Scheduler and completes.
`static Mono<Long>`	Mono.`delay(Duration duration, Scheduler timer)` Create a Mono which delays an onNext signal by a given `duration` on a provided `Scheduler` and completes.
`Mono<T>`	Mono.`delayElement(Duration delay)` Delay this `Mono` element (`Subscriber.onNext(T)` signal) by a given duration.
`Mono<T>`	Mono.`delayElement(Duration delay, Scheduler timer)` Delay this `Mono` element (`Subscriber.onNext(T)` signal) by a given `Duration`, on a particular `Scheduler`.
`Mono<T>`	Mono.`delaySubscription(Duration delay)` Delay the `subscription` to this `Mono` source until the given period elapses.
`Mono<T>`	Mono.`delaySubscription(Duration delay, Scheduler timer)` Delay the `subscription` to this `Mono` source until the given `Duration` elapses.
`<U> Mono<T>`	Mono.`delaySubscription(Publisher<U> subscriptionDelay)` Delay the subscription to this `Mono` until another `Publisher` signals a value or completes.
`Mono<T>`	Mono.`delayUntil(Function<? super T,? extends Publisher<?>> triggerProvider)` Subscribe to this `Mono` and another `Publisher` that is generated from this Mono's element and which will be used as a trigger for relaying said element.
`<X> Mono<X>`	Mono.`dematerialize()` An operator working only if this `Mono` emits onNext, onError or onComplete `Signal` instances, transforming these `materialized` signals into real signals on the `Subscriber`.
`Mono<T>`	Mono.`doAfterTerminate(Runnable afterTerminate)` Add behavior (side-effect) triggered after the `Mono` terminates, either by completing downstream successfully or with an error.
`Mono<T>`	Mono.`doFinally(Consumer<SignalType> onFinally)` Add behavior triggering after the `Mono` terminates for any reason, including cancellation.
`Mono<T>`	Mono.`doFirst(Runnable onFirst)` Add behavior (side-effect) triggered before the `Mono` is subscribed to, which should be the first event after assembly time.
`Mono<T>`	Mono.`doOnCancel(Runnable onCancel)` Add behavior triggered when the `Mono` is cancelled.
`<R> Mono<T>`	Mono.`doOnDiscard(Class<R> type, Consumer<? super R> discardHook)` Potentially modify the behavior of the whole chain of operators upstream of this one to conditionally clean up elements that get discarded by these operators.
`Mono<T>`	Mono.`doOnEach(Consumer<? super Signal<T>> signalConsumer)` Add behavior triggered when the `Mono` emits an item, fails with an error or completes successfully.
`<E extends Throwable> Mono<T>`	Mono.`doOnError(Class<E> exceptionType, Consumer<? super E> onError)` Add behavior triggered when the `Mono` completes with an error matching the given exception type.
`Mono<T>`	Mono.`doOnError(Consumer<? super Throwable> onError)` Add behavior triggered when the `Mono` completes with an error.
`Mono<T>`	Mono.`doOnError(Predicate<? super Throwable> predicate, Consumer<? super Throwable> onError)` Add behavior triggered when the `Mono` completes with an error matching the given predicate.
`Mono<T>`	Mono.`doOnNext(Consumer<? super T> onNext)` Add behavior triggered when the `Mono` emits a data successfully.
`Mono<T>`	Mono.`doOnRequest(LongConsumer consumer)` Add behavior triggering a `LongConsumer` when the `Mono` receives any request.
`Mono<T>`	Mono.`doOnSubscribe(Consumer<? super Subscription> onSubscribe)` Add behavior (side-effect) triggered when the `Mono` is being subscribed, that is to say when a `Subscription` has been produced by the `Publisher` and is being passed to the `Subscriber.onSubscribe(Subscription)`.
`Mono<T>`	Mono.`doOnSuccess(Consumer<? super T> onSuccess)` Add behavior triggered as soon as the `Mono` can be considered to have completed successfully.
`Mono<T>`	Mono.`doOnTerminate(Runnable onTerminate)` Add behavior triggered when the `Mono` terminates, either by completing with a value, completing empty or failing with an error.
`Mono<Tuple2<Long,T>>`	Mono.`elapsed()` Map this `Mono` into `Tuple2<Long, T>` of timemillis and source data.
`Mono<Tuple2<Long,T>>`	Mono.`elapsed(Scheduler scheduler)` Map this `Mono` sequence into `Tuple2<Long, T>` of timemillis and source data.
`Mono<T>`	Flux.`elementAt(int index)` Emit only the element at the given index position or `IndexOutOfBoundsException` if the sequence is shorter.
`Mono<T>`	Flux.`elementAt(int index, T defaultValue)` Emit only the element at the given index position or fall back to a default value if the sequence is shorter.
`static <T> Mono<T>`	Mono.`empty()` Create a `Mono` that completes without emitting any item.
`static <T> Mono<T>`	Mono.`error(Supplier<? extends Throwable> errorSupplier)` Create a `Mono` that terminates with an error immediately after being subscribed to.
`static <T> Mono<T>`	Mono.`error(Throwable error)` Create a `Mono` that terminates with the specified error immediately after being subscribed to.
`Mono<T>`	Mono.`filter(Predicate<? super T> tester)` If this `Mono` is valued, test the result and replay it if predicate returns true.
`Mono<T>`	Mono.`filterWhen(Function<? super T,? extends Publisher<Boolean>> asyncPredicate)` If this `Mono` is valued, test the value asynchronously using a generated `Publisher<Boolean>` test.
`static <T> Mono<T>`	Mono.`first(Iterable<? extends Mono<? extends T>> monos)` Deprecated. use `firstWithSignal(Iterable)`. To be removed in reactor 3.5.
`static <T> Mono<T>`	Mono.`first(Mono<? extends T>... monos)` Deprecated. use `firstWithSignal(Mono[])`. To be removed in reactor 3.5.
`static <T> Mono<T>`	Mono.`firstWithSignal(Iterable<? extends Mono<? extends T>> monos)` Pick the first `Mono` to emit any signal (value, empty completion or error) and replay that signal, effectively behaving like the fastest of these competing sources.
`static <T> Mono<T>`	Mono.`firstWithSignal(Mono<? extends T>... monos)` Pick the first `Mono` to emit any signal (value, empty completion or error) and replay that signal, effectively behaving like the fastest of these competing sources.
`static <T> Mono<T>`	Mono.`firstWithValue(Iterable<? extends Mono<? extends T>> monos)` Pick the first `Mono` source to emit any value and replay that signal, effectively behaving like the source that first emits an `onNext`.
`static <T> Mono<T>`	Mono.`firstWithValue(Mono<? extends T> first, Mono<? extends T>... others)` Pick the first `Mono` source to emit any value and replay that signal, effectively behaving like the source that first emits an `onNext`.
`<R> Mono<R>`	Mono.`flatMap(Function<? super T,? extends Mono<? extends R>> transformer)` Transform the item emitted by this `Mono` asynchronously, returning the value emitted by another `Mono` (possibly changing the value type).
`static <T> Mono<T>`	Mono.`from(Publisher<? extends T> source)` Expose the specified `Publisher` with the `Mono` API, and ensure it will emit 0 or 1 item.
`static <T> Mono<T>`	Mono.`fromCallable(Callable<? extends T> supplier)` Create a `Mono` producing its value using the provided `Callable`.
`static <T> Mono<T>`	Mono.`fromCompletionStage(CompletionStage<? extends T> completionStage)` Create a `Mono`, producing its value using the provided `CompletionStage`.
`static <T> Mono<T>`	Mono.`fromCompletionStage(Supplier<? extends CompletionStage<? extends T>> stageSupplier)` Create a `Mono` that wraps a lazily-supplied `CompletionStage` on subscription, emitting the value produced by the `CompletionStage`.
`static <I> Mono<I>`	Mono.`fromDirect(Publisher<? extends I> source)` Convert a `Publisher` to a `Mono` without any cardinality check (ie this method doesn't cancel the source past the first element).
`static <T> Mono<T>`	Mono.`fromFuture(CompletableFuture<? extends T> future)` Create a `Mono`, producing its value using the provided `CompletableFuture` and cancelling the future if the Mono gets cancelled.
`static <T> Mono<T>`	Mono.`fromFuture(CompletableFuture<? extends T> future, boolean suppressCancel)` Create a `Mono`, producing its value using the provided `CompletableFuture` and optionally cancelling the future if the Mono gets cancelled (if `suppressCancel == false`).
`static <T> Mono<T>`	Mono.`fromFuture(Supplier<? extends CompletableFuture<? extends T>> futureSupplier)` Create a `Mono` that wraps a lazily-supplied `CompletableFuture` on subscription, emitting the value produced by the future and cancelling the future if the Mono gets cancelled.
`static <T> Mono<T>`	Mono.`fromFuture(Supplier<? extends CompletableFuture<? extends T>> futureSupplier, boolean suppressCancel)` Create a `Mono` that wraps a lazily-supplied `CompletableFuture` on subscription, emitting the value produced by the future and optionally cancelling the future if the Mono gets cancelled (if `suppressCancel == false`).
`static <T> Mono<T>`	Mono.`fromRunnable(Runnable runnable)` Create a `Mono` that completes empty once the provided `Runnable` has been executed.
`static <T> Mono<T>`	Mono.`fromSupplier(Supplier<? extends T> supplier)` Create a `Mono`, producing its value using the provided `Supplier`.
`<R> Mono<R>`	Mono.`handle(BiConsumer<? super T,SynchronousSink<R>> handler)` Handle the items emitted by this `Mono` by calling a biconsumer with the output sink for each onNext.
`Mono<Boolean>`	Mono.`hasElement()` Emit a single boolean true if this `Mono` has an element.
`Mono<Boolean>`	Flux.`hasElement(T value)` Emit a single boolean true if any of the elements of this `Flux` sequence is equal to the provided value.
`Mono<Boolean>`	Flux.`hasElements()` Emit a single boolean true if this `Flux` sequence has at least one element.
`Mono<T>`	Mono.`hide()` Hides the identity of this `Mono` instance.
`Mono<T>`	Mono.`ignoreElement()` Ignores onNext signal (dropping it) and only propagates termination events.
`Mono<T>`	Flux.`ignoreElements()` Ignores onNext signals (dropping them) and only propagate termination events.
`static <T> Mono<T>`	Mono.`ignoreElements(Publisher<T> source)` Create a new `Mono` that ignores elements from the source (dropping them), but completes when the source completes.
`static <T> Mono<T>`	Mono.`just(T data)` Create a new `Mono` that emits the specified item, which is captured at instantiation time.
`static <T> Mono<T>`	Mono.`justOrEmpty(Optional<? extends T> data)` Create a new `Mono` that emits the specified item if `Optional.isPresent()` otherwise only emits onComplete.
`static <T> Mono<T>`	Mono.`justOrEmpty(T data)` Create a new `Mono` that emits the specified item if non null otherwise only emits onComplete.
`Mono<T>`	Flux.`last()` Emit the last element observed before complete signal as a `Mono`, or emit `NoSuchElementException` error if the source was empty.
`Mono<T>`	Flux.`last(T defaultValue)` Emit the last element observed before complete signal as a `Mono`, or emit the `defaultValue` if the source was empty.
`Mono<T>`	Mono.`log()` Observe all Reactive Streams signals and trace them using `Logger` support.
`Mono<T>`	Mono.`log(Logger logger)` Observe Reactive Streams signals matching the passed filter `options` and trace them using a specific user-provided `Logger`, at `Level.INFO` level.
`Mono<T>`	Mono.`log(Logger logger, Level level, boolean showOperatorLine, SignalType... options)` Observe Reactive Streams signals matching the passed filter `options` and trace them using a specific user-provided `Logger`, at the given `Level`.
`Mono<T>`	Mono.`log(String category)` Observe all Reactive Streams signals and use `Logger` support to handle trace implementation.
`Mono<T>`	Mono.`log(String category, Level level, boolean showOperatorLine, SignalType... options)` Observe Reactive Streams signals matching the passed filter `options` and use `Logger` support to handle trace implementation.
`Mono<T>`	Mono.`log(String category, Level level, SignalType... options)` Observe Reactive Streams signals matching the passed flags `options` and use `Logger` support to handle trace implementation.
`<R> Mono<R>`	Mono.`map(Function<? super T,? extends R> mapper)` Transform the item emitted by this `Mono` by applying a synchronous function to it.
`<R> Mono<R>`	Mono.`mapNotNull(Function<? super T,? extends R> mapper)` Transform the item emitted by this `Mono` by applying a synchronous function to it, which is allowed to produce a `null` value.
`Mono<Signal<T>>`	Mono.`materialize()` Transform incoming onNext, onError and onComplete signals into `Signal` instances, materializing these signals.
`Mono<T>`	Mono.`metrics()` Deprecated. Prefer using the `tap(SignalListenerFactory)` with the `SignalListenerFactory` provided by the new reactor-core-micrometer module. To be removed in 3.6.0 at the earliest.
`Mono<T>`	Mono.`name(String name)` Give a name to this sequence, which can be retrieved using `Scannable.name()` as long as this is the first reachable `Scannable.parents()`.
`static <T> Mono<T>`	Mono.`never()` Return a `Mono` that will never signal any data, error or completion signal, essentially running indefinitely.
`Mono<T>`	Flux.`next()` Emit only the first item emitted by this `Flux`, into a new `Mono`.
`<U> Mono<U>`	Mono.`ofType(Class<U> clazz)` Evaluate the emitted value against the given `Class` type.
`protected static <T> Mono<T>`	Mono.`onAssembly(Mono<T> source)` To be used by custom operators: invokes assembly `Hooks` pointcut given a `Mono`, potentially returning a new `Mono`.
`Mono<T>`	Mono.`onErrorComplete()` Simply complete the sequence by replacing an `onError signal` with an `onComplete signal`.
`Mono<T>`	Mono.`onErrorComplete(Class<? extends Throwable> type)` Simply complete the sequence by replacing an `onError signal` with an `onComplete signal` if the error matches the given `Class`.
`Mono<T>`	Mono.`onErrorComplete(Predicate<? super Throwable> predicate)` Simply complete the sequence by replacing an `onError signal` with an `onComplete signal` if the error matches the given `Predicate`.
`Mono<T>`	Mono.`onErrorContinue(BiConsumer<Throwable,Object> errorConsumer)` Let compatible operators upstream recover from errors by dropping the incriminating element from the sequence and continuing with subsequent elements.
`<E extends Throwable> Mono<T>`	Mono.`onErrorContinue(Class<E> type, BiConsumer<Throwable,Object> errorConsumer)` Let compatible operators upstream recover from errors by dropping the incriminating element from the sequence and continuing with subsequent elements.
`<E extends Throwable> Mono<T>`	Mono.`onErrorContinue(Predicate<E> errorPredicate, BiConsumer<Throwable,Object> errorConsumer)` Let compatible operators upstream recover from errors by dropping the incriminating element from the sequence and continuing with subsequent elements.
`<E extends Throwable> Mono<T>`	Mono.`onErrorMap(Class<E> type, Function<? super E,? extends Throwable> mapper)` Transform an error emitted by this `Mono` by synchronously applying a function to it if the error matches the given type.
`Mono<T>`	Mono.`onErrorMap(Function<? super Throwable,? extends Throwable> mapper)` Transform any error emitted by this `Mono` by synchronously applying a function to it.
`Mono<T>`	Mono.`onErrorMap(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Throwable> mapper)` Transform an error emitted by this `Mono` by synchronously applying a function to it if the error matches the given predicate.
`<E extends Throwable> Mono<T>`	Mono.`onErrorResume(Class<E> type, Function<? super E,? extends Mono<? extends T>> fallback)` Subscribe to a fallback publisher when an error matching the given type occurs, using a function to choose the fallback depending on the error.
`Mono<T>`	Mono.`onErrorResume(Function<? super Throwable,? extends Mono<? extends T>> fallback)` Subscribe to a fallback publisher when any error occurs, using a function to choose the fallback depending on the error.
`Mono<T>`	Mono.`onErrorResume(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Mono<? extends T>> fallback)` Subscribe to a fallback publisher when an error matching a given predicate occurs.
`<E extends Throwable> Mono<T>`	Mono.`onErrorReturn(Class<E> type, T fallbackValue)` Simply emit a captured fallback value when an error of the specified type is observed on this `Mono`.
`Mono<T>`	Mono.`onErrorReturn(Predicate<? super Throwable> predicate, T fallbackValue)` Simply emit a captured fallback value when an error matching the given predicate is observed on this `Mono`.
`Mono<T>`	Mono.`onErrorReturn(T fallbackValue)` Simply emit a captured fallback value when any error is observed on this `Mono`.
`Mono<T>`	Mono.`onErrorStop()` If an `onErrorContinue(BiConsumer)` variant has been used downstream, reverts to the default 'STOP' mode where errors are terminal events upstream.
`Mono<T>`	Mono.`onTerminateDetach()` Detaches both the child `Subscriber` and the `Subscription` on termination or cancellation.
`Mono<T>`	Mono.`or(Mono<? extends T> other)` Emit the first available signal from this mono or the other mono.
`<R> Mono<R>`	Mono.`publish(Function<? super Mono<T>,? extends Mono<? extends R>> transform)` Share a `Mono` for the duration of a function that may transform it and consume it as many times as necessary without causing multiple subscriptions to the upstream.
`Mono<T>`	Flux.`publishNext()` Deprecated. use `Flux.shareNext()` instead, or use `publish().next()` if you need to ``connect()`. To be removed in 3.5.0
`Mono<T>`	Mono.`publishOn(Scheduler scheduler)` Run onNext, onComplete and onError on a supplied `Scheduler` `Worker`.
`<A> Mono<A>`	Flux.`reduce(A initial, BiFunction<A,? super T,A> accumulator)` Reduce the values from this `Flux` sequence into a single object matching the type of a seed value.
`Mono<T>`	Flux.`reduce(BiFunction<T,T,T> aggregator)` Reduce the values from this `Flux` sequence into a single object of the same type than the emitted items.
`Mono<T>`	ParallelFlux.`reduce(BiFunction<T,T,T> reducer)` Reduces all values within a 'rail' and across 'rails' with a reducer function into a single sequential value.
`<A> Mono<A>`	Flux.`reduceWith(Supplier<A> initial, BiFunction<A,? super T,A> accumulator)` Reduce the values from this `Flux` sequence into a single object matching the type of a lazily supplied seed value.
`Mono<T>`	Mono.`repeatWhenEmpty(Function<Flux<Long>,? extends Publisher<?>> repeatFactory)` Repeatedly subscribe to this `Mono` as long as the current subscription to this `Mono` completes empty and the companion `Publisher` produces an onNext signal.
`Mono<T>`	Mono.`repeatWhenEmpty(int maxRepeat, Function<Flux<Long>,? extends Publisher<?>> repeatFactory)` Repeatedly subscribe to this `Mono` as long as the current subscription to this `Mono` completes empty and the companion `Publisher` produces an onNext signal.
`Mono<T>`	Mono.`retry()` Re-subscribes to this `Mono` sequence if it signals any error, indefinitely.
`Mono<T>`	Mono.`retry(long numRetries)` Re-subscribes to this `Mono` sequence if it signals any error, for a fixed number of times.
`Mono<T>`	Mono.`retryWhen(Retry retrySpec)` Retries this `Mono` in response to signals emitted by a companion `Publisher`.
`static <T> Mono<Boolean>`	Mono.`sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2)` Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.
`static <T> Mono<Boolean>`	Mono.`sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2, BiPredicate<? super T,? super T> isEqual)` Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
`static <T> Mono<Boolean>`	Mono.`sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2, BiPredicate<? super T,? super T> isEqual, int prefetch)` Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
`Mono<T>`	Mono.`share()` Prepare a `Mono` which shares this `Mono` result similar to `Flux.shareNext()`.
`Mono<T>`	Flux.`shareNext()` Prepare a `Mono` which shares this `Flux` sequence and dispatches the first observed item to subscribers.
`Mono<T>`	Flux.`single()` Expect and emit a single item from this `Flux` source or signal `NoSuchElementException` for an empty source, or `IndexOutOfBoundsException` for a source with more than one element.
`Mono<T>`	Mono.`single()` Expect exactly one item from this `Mono` source or signal `NoSuchElementException` for an empty source.
`Mono<T>`	Flux.`single(T defaultValue)` Expect and emit a single item from this `Flux` source and emit a default value for an empty source, but signal an `IndexOutOfBoundsException` for a source with more than one element.
`Mono<Optional<T>>`	Mono.`singleOptional()` Wrap the item produced by this `Mono` source into an Optional or emit an empty Optional for an empty source.
`Mono<T>`	Flux.`singleOrEmpty()` Expect and emit a single item from this `Flux` source, and accept an empty source but signal an `IndexOutOfBoundsException` for a source with more than one element.
`Mono<T>`	Mono.`subscribeOn(Scheduler scheduler)` Run subscribe, onSubscribe and request on a specified `Scheduler`'s `Scheduler.Worker`.
`Mono<T>`	Mono.`switchIfEmpty(Mono<? extends T> alternate)` Fallback to an alternative `Mono` if this mono is completed without data
`Mono<T>`	Mono.`tag(String key, String value)` Tag this mono with a key/value pair.
`Mono<T>`	Mono.`take(Duration duration)` Give this Mono a chance to resolve within a specified time frame but complete if it doesn't.
`Mono<T>`	Mono.`take(Duration duration, Scheduler timer)` Give this Mono a chance to resolve within a specified time frame but complete if it doesn't.
`Mono<T>`	Mono.`takeUntilOther(Publisher<?> other)` Give this Mono a chance to resolve before a companion `Publisher` emits.
`Mono<T>`	Mono.`tap(Function<ContextView,SignalListener<T>> listenerGenerator)` Tap into Reactive Streams signals emitted or received by this `Mono` and notify a stateful per-`Subscriber` `SignalListener`.
`Mono<T>`	Mono.`tap(SignalListenerFactory<T,?> listenerFactory)` Tap into Reactive Streams signals emitted or received by this `Mono` and notify a stateful per-`Subscriber` `SignalListener` created by the provided `SignalListenerFactory`.
`Mono<T>`	Mono.`tap(Supplier<SignalListener<T>> simpleListenerGenerator)` Tap into Reactive Streams signals emitted or received by this `Mono` and notify a stateful per-`Subscriber` `SignalListener`.
`Mono<Void>`	Flux.`then()` Return a `Mono<Void>` that completes when this `Flux` completes.
`Mono<Void>`	ParallelFlux.`then()` Emit an onComplete or onError signal once all values across 'rails' have been observed.
`Mono<Void>`	Mono.`then()` Return a `Mono<Void>` which only replays complete and error signals from this `Mono`.
`<V> Mono<V>`	Flux.`then(Mono<V> other)` Let this `Flux` complete then play signals from a provided `Mono`.
`<V> Mono<V>`	Mono.`then(Mono<V> other)` Let this `Mono` complete then play another Mono.
`Mono<Void>`	Flux.`thenEmpty(Publisher<Void> other)` Return a `Mono<Void>` that waits for this `Flux` to complete then for a supplied `Publisher<Void>` to also complete.
`Mono<Void>`	Mono.`thenEmpty(Publisher<Void> other)` Return a `Mono<Void>` that waits for this `Mono` to complete then for a supplied `Publisher<Void>` to also complete.
`<V> Mono<V>`	Mono.`thenReturn(V value)` Let this `Mono` complete successfully, then emit the provided value.
`Mono<Timed<T>>`	Mono.`timed()` Times this `Mono` `Subscriber.onNext(Object)` event, encapsulated into a `Timed` object that lets downstream consumer look at various time information gathered with nanosecond resolution using the default clock (`Schedulers.parallel()`): `Timed.elapsed()`: the time in nanoseconds since subscription, as a `Duration`.
`Mono<Timed<T>>`	Mono.`timed(Scheduler clock)` Times this `Mono` `Subscriber.onNext(Object)` event, encapsulated into a `Timed` object that lets downstream consumer look at various time information gathered with nanosecond resolution using the provided `Scheduler` as a clock: `Timed.elapsed()`: the time in nanoseconds since subscription, as a `Duration`.
`Mono<T>`	Mono.`timeout(Duration timeout)` Propagate a `TimeoutException` in case no item arrives within the given `Duration`.
`Mono<T>`	Mono.`timeout(Duration timeout, Mono<? extends T> fallback)` Switch to a fallback `Mono` in case no item arrives within the given `Duration`.
`Mono<T>`	Mono.`timeout(Duration timeout, Mono<? extends T> fallback, Scheduler timer)` Switch to a fallback `Mono` in case an item doesn't arrive before the given period, as measured on the provided `Scheduler`.
`Mono<T>`	Mono.`timeout(Duration timeout, Scheduler timer)` Signal a `TimeoutException` error in case an item doesn't arrive before the given period, as measured on the provided `Scheduler`.
`<U> Mono<T>`	Mono.`timeout(Publisher<U> firstTimeout)` Signal a `TimeoutException` in case the item from this `Mono` has not been emitted before the given `Publisher` emits.
`<U> Mono<T>`	Mono.`timeout(Publisher<U> firstTimeout, Mono<? extends T> fallback)` Switch to a fallback `Publisher` in case the item from this `Mono` has not been emitted before the given `Publisher` emits.
`Mono<Tuple2<Long,T>>`	Mono.`timestamp()` If this `Mono` is valued, emit a `Tuple2` pair of T1 the current clock time in millis (as a `Long` measured by the `parallel` Scheduler) and T2 the emitted data (as a `T`).
`Mono<Tuple2<Long,T>>`	Mono.`timestamp(Scheduler scheduler)` If this `Mono` is valued, emit a `Tuple2` pair of T1 the current clock time in millis (as a `Long` measured by the provided `Scheduler`) and T2 the emitted data (as a `T`).
`<V> Mono<V>`	Mono.`transform(Function<? super Mono<T>,? extends Publisher<V>> transformer)` Transform this `Mono` in order to generate a target `Mono`.
`<V> Mono<V>`	Mono.`transformDeferred(Function<? super Mono<T>,? extends Publisher<V>> transformer)` Defer the given transformation to this `Mono` in order to generate a target `Mono` type.
`<V> Mono<V>`	Mono.`transformDeferredContextual(BiFunction<? super Mono<T>,? super ContextView,? extends Publisher<V>> transformer)` Defer the given transformation to this `Mono` in order to generate a target `Mono` type.
`static <T,D> Mono<T>`	Mono.`using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Mono<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup)` Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
`static <T,D> Mono<T>`	Mono.`using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Mono<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup, boolean eager)` Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
`static <T,D> Mono<T>`	Mono.`usingWhen(Publisher<D> resourceSupplier, Function<? super D,? extends Mono<? extends T>> resourceClosure, Function<? super D,? extends Publisher<?>> asyncCleanup)` Uses a resource, generated by a `Publisher` for each individual `Subscriber`, to derive a `Mono`.
`static <T,D> Mono<T>`	Mono.`usingWhen(Publisher<D> resourceSupplier, Function<? super D,? extends Mono<? extends T>> resourceClosure, Function<? super D,? extends Publisher<?>> asyncComplete, BiFunction<? super D,? super Throwable,? extends Publisher<?>> asyncError, Function<? super D,? extends Publisher<?>> asyncCancel)` Uses a resource, generated by a `Publisher` for each individual `Subscriber`, to derive a `Mono`.Note that all steps of the operator chain that would need the resource to be in an open stable state need to be described inside the `resourceClosure` `Function`.
`static Mono<Void>`	Mono.`when(Iterable<? extends Publisher<?>> sources)` Aggregate given publishers into a new Mono that will be fulfilled when all of the given Publishers have completed.
`static Mono<Void>`	Mono.`when(Publisher<?>... sources)` Aggregate given publishers into a new Mono that will be fulfilled when all of the given sources have completed.
`static Mono<Void>`	Mono.`whenDelayError(Iterable<? extends Publisher<?>> sources)` Aggregate given publishers into a new Mono that will be fulfilled when all of the given sources have completed.
`static Mono<Void>`	Mono.`whenDelayError(Publisher<?>... sources)` Merge given publishers into a new Mono that will be fulfilled when all of the given sources have completed.
`static <R> Mono<R>`	Mono.`zip(Function<? super Object[],? extends R> combinator, Mono<?>... monos)` Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values according to the provided combinator function.
`static <R> Mono<R>`	Mono.`zip(Iterable<? extends Mono<?>> monos, Function<? super Object[],? extends R> combinator)` Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values according to the provided combinator function.
`static <T1,T2> Mono<Tuple2<T1,T2>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple2`.
`static <T1,T2,O> Mono<O>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, BiFunction<? super T1,? super T2,? extends O> combinator)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values as defined by the combinator function.
`static <T1,T2,T3> Mono<Tuple3<T1,T2,T3>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple3`.
`static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple4`.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple5`.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6`.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8`.
`static <R> Mono<R>`	Mono.`zipDelayError(Function<? super Object[],? extends R> combinator, Mono<?>... monos)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values according to the provided combinator function and delaying errors.
`static <R> Mono<R>`	Mono.`zipDelayError(Iterable<? extends Mono<?>> monos, Function<? super Object[],? extends R> combinator)` Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item.
`static <T1,T2> Mono<Tuple2<T1,T2>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple2` and delaying errors.
`static <T1,T2,T3> Mono<Tuple3<T1,T2,T3>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3)` Merge given monos into a new Mono that will be fulfilled when all of the given Mono Monos have produced an item, aggregating their values into a `Tuple3` and delaying errors.
`static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple4` and delaying errors.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple5` and delaying errors.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8` and delaying errors.
`<T2> Mono<Tuple2<T,T2>>`	Mono.`zipWhen(Function<T,Mono<? extends T2>> rightGenerator)` Wait for the result from this mono, use it to create a second mono via the provided `rightGenerator` function and combine both results into a `Tuple2`.
`<T2,O> Mono<O>`	Mono.`zipWhen(Function<T,Mono<? extends T2>> rightGenerator, BiFunction<T,T2,O> combinator)` Wait for the result from this mono, use it to create a second mono via the provided `rightGenerator` function and combine both results into an arbitrary `O` object, as defined by the provided `combinator` function.
`<T2> Mono<Tuple2<T,T2>>`	Mono.`zipWith(Mono<? extends T2> other)` Combine the result from this mono and another into a `Tuple2`.
`<T2,O> Mono<O>`	Mono.`zipWith(Mono<? extends T2> other, BiFunction<? super T,? super T2,? extends O> combinator)` Combine the result from this mono and another into an arbitrary `O` object, as defined by the provided `combinator` function.

Methods in reactor.core.publisher with parameters of type Mono
Modifier and Type	Method and Description
`static <T> Mono<T>`	Mono.`first(Mono<? extends T>... monos)` Deprecated. use `firstWithSignal(Mono[])`. To be removed in reactor 3.5.
`static <T> Mono<T>`	Mono.`firstWithSignal(Mono<? extends T>... monos)` Pick the first `Mono` to emit any signal (value, empty completion or error) and replay that signal, effectively behaving like the fastest of these competing sources.
`static <T> Mono<T>`	Mono.`firstWithValue(Mono<? extends T> first, Mono<? extends T>... others)` Pick the first `Mono` source to emit any value and replay that signal, effectively behaving like the source that first emits an `onNext`.
`static <T> Mono<T>`	Mono.`firstWithValue(Mono<? extends T> first, Mono<? extends T>... others)` Pick the first `Mono` source to emit any value and replay that signal, effectively behaving like the source that first emits an `onNext`.
`protected static <T> Mono<T>`	Mono.`onAssembly(Mono<T> source)` To be used by custom operators: invokes assembly `Hooks` pointcut given a `Mono`, potentially returning a new `Mono`.
`Mono<T>`	Mono.`or(Mono<? extends T> other)` Emit the first available signal from this mono or the other mono.
`Mono<T>`	Mono.`switchIfEmpty(Mono<? extends T> alternate)` Fallback to an alternative `Mono` if this mono is completed without data
`<V> Mono<V>`	Flux.`then(Mono<V> other)` Let this `Flux` complete then play signals from a provided `Mono`.
`<V> Mono<V>`	Mono.`then(Mono<V> other)` Let this `Mono` complete then play another Mono.
`Mono<T>`	Mono.`timeout(Duration timeout, Mono<? extends T> fallback)` Switch to a fallback `Mono` in case no item arrives within the given `Duration`.
`Mono<T>`	Mono.`timeout(Duration timeout, Mono<? extends T> fallback, Scheduler timer)` Switch to a fallback `Mono` in case an item doesn't arrive before the given period, as measured on the provided `Scheduler`.
`<U> Mono<T>`	Mono.`timeout(Publisher<U> firstTimeout, Mono<? extends T> fallback)` Switch to a fallback `Publisher` in case the item from this `Mono` has not been emitted before the given `Publisher` emits.
`static <R> Mono<R>`	Mono.`zip(Function<? super Object[],? extends R> combinator, Mono<?>... monos)` Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values according to the provided combinator function.
`static <T1,T2> Mono<Tuple2<T1,T2>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple2`.
`static <T1,T2> Mono<Tuple2<T1,T2>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple2`.
`static <T1,T2,O> Mono<O>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, BiFunction<? super T1,? super T2,? extends O> combinator)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values as defined by the combinator function.
`static <T1,T2,O> Mono<O>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, BiFunction<? super T1,? super T2,? extends O> combinator)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values as defined by the combinator function.
`static <T1,T2,T3> Mono<Tuple3<T1,T2,T3>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple3`.
`static <T1,T2,T3> Mono<Tuple3<T1,T2,T3>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple3`.
`static <T1,T2,T3> Mono<Tuple3<T1,T2,T3>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple3`.
`static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple4`.
`static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple4`.
`static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple4`.
`static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple4`.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple5`.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple5`.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple5`.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple5`.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple5`.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6`.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6`.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6`.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6`.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6`.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6`.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7`.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7`.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7`.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7`.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7`.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7`.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8`.
`static <R> Mono<R>`	Mono.`zipDelayError(Function<? super Object[],? extends R> combinator, Mono<?>... monos)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values according to the provided combinator function and delaying errors.
`static <T1,T2> Mono<Tuple2<T1,T2>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple2` and delaying errors.
`static <T1,T2> Mono<Tuple2<T1,T2>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple2` and delaying errors.
`static <T1,T2,T3> Mono<Tuple3<T1,T2,T3>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3)` Merge given monos into a new Mono that will be fulfilled when all of the given Mono Monos have produced an item, aggregating their values into a `Tuple3` and delaying errors.
`static <T1,T2,T3> Mono<Tuple3<T1,T2,T3>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3)` Merge given monos into a new Mono that will be fulfilled when all of the given Mono Monos have produced an item, aggregating their values into a `Tuple3` and delaying errors.
`static <T1,T2,T3> Mono<Tuple3<T1,T2,T3>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3)` Merge given monos into a new Mono that will be fulfilled when all of the given Mono Monos have produced an item, aggregating their values into a `Tuple3` and delaying errors.
`static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple4` and delaying errors.
`static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple4` and delaying errors.
`static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple4` and delaying errors.
`static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple4` and delaying errors.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple5` and delaying errors.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple5` and delaying errors.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple5` and delaying errors.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple5` and delaying errors.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple5` and delaying errors.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6` and delaying errors.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6` and delaying errors.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6` and delaying errors.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6` and delaying errors.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6` and delaying errors.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple6` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7> Mono<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple7` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8` and delaying errors.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Mono<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	Mono.`zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8)` Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a `Tuple8` and delaying errors.
`<T2> Mono<Tuple2<T,T2>>`	Mono.`zipWith(Mono<? extends T2> other)` Combine the result from this mono and another into a `Tuple2`.
`<T2,O> Mono<O>`	Mono.`zipWith(Mono<? extends T2> other, BiFunction<? super T,? super T2,? extends O> combinator)` Combine the result from this mono and another into an arbitrary `O` object, as defined by the provided `combinator` function.

Method parameters in reactor.core.publisher with type arguments of type Mono
Modifier and Type	Method and Description
`<P> P`	Mono.`as(Function<? super Mono<T>,P> transformer)` Transform this `Mono` into a target type.
`Mono<T>`	Mono.`cacheInvalidateWhen(Function<? super T,Mono<Void>> invalidationTriggerGenerator)` Cache `onNext` signal received from the source and replay it to other subscribers, while allowing invalidation via a `Mono<Void>` companion trigger generated from the currently cached value.
`Mono<T>`	Mono.`cacheInvalidateWhen(Function<? super T,Mono<Void>> invalidationTriggerGenerator, Consumer<? super T> onInvalidate)` Cache `onNext` signal received from the source and replay it to other subscribers, while allowing invalidation via a `Mono<Void>` companion trigger generated from the currently cached value.
`static <T> Mono<T>`	Mono.`defer(Supplier<? extends Mono<? extends T>> supplier)` Create a `Mono` provider that will `supply` a target `Mono` to subscribe to for each `Subscriber` downstream.
`static <T> Mono<T>`	Mono.`deferContextual(Function<ContextView,? extends Mono<? extends T>> contextualMonoFactory)` Create a `Mono` provider that will `supply` a target `Mono` to subscribe to for each `Subscriber` downstream.
`static <T> Mono<T>`	Mono.`first(Iterable<? extends Mono<? extends T>> monos)` Deprecated. use `firstWithSignal(Iterable)`. To be removed in reactor 3.5.
`static <T> Mono<T>`	Mono.`firstWithSignal(Iterable<? extends Mono<? extends T>> monos)` Pick the first `Mono` to emit any signal (value, empty completion or error) and replay that signal, effectively behaving like the fastest of these competing sources.
`static <T> Mono<T>`	Mono.`firstWithValue(Iterable<? extends Mono<? extends T>> monos)` Pick the first `Mono` source to emit any value and replay that signal, effectively behaving like the source that first emits an `onNext`.
`<R> Mono<R>`	Mono.`flatMap(Function<? super T,? extends Mono<? extends R>> transformer)` Transform the item emitted by this `Mono` asynchronously, returning the value emitted by another `Mono` (possibly changing the value type).
`<E extends Throwable> Mono<T>`	Mono.`onErrorResume(Class<E> type, Function<? super E,? extends Mono<? extends T>> fallback)` Subscribe to a fallback publisher when an error matching the given type occurs, using a function to choose the fallback depending on the error.
`Mono<T>`	Mono.`onErrorResume(Function<? super Throwable,? extends Mono<? extends T>> fallback)` Subscribe to a fallback publisher when any error occurs, using a function to choose the fallback depending on the error.
`Mono<T>`	Mono.`onErrorResume(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Mono<? extends T>> fallback)` Subscribe to a fallback publisher when an error matching a given predicate occurs.
`<R> Mono<R>`	Mono.`publish(Function<? super Mono<T>,? extends Mono<? extends R>> transform)` Share a `Mono` for the duration of a function that may transform it and consume it as many times as necessary without causing multiple subscriptions to the upstream.
`<R> Mono<R>`	Mono.`publish(Function<? super Mono<T>,? extends Mono<? extends R>> transform)` Share a `Mono` for the duration of a function that may transform it and consume it as many times as necessary without causing multiple subscriptions to the upstream.
`<V> Mono<V>`	Mono.`transform(Function<? super Mono<T>,? extends Publisher<V>> transformer)` Transform this `Mono` in order to generate a target `Mono`.
`<V> Mono<V>`	Mono.`transformDeferred(Function<? super Mono<T>,? extends Publisher<V>> transformer)` Defer the given transformation to this `Mono` in order to generate a target `Mono` type.
`<V> Mono<V>`	Mono.`transformDeferredContextual(BiFunction<? super Mono<T>,? super ContextView,? extends Publisher<V>> transformer)` Defer the given transformation to this `Mono` in order to generate a target `Mono` type.
`static <T,D> Mono<T>`	Mono.`using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Mono<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup)` Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
`static <T,D> Mono<T>`	Mono.`using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Mono<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup, boolean eager)` Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
`static <T,D> Mono<T>`	Mono.`usingWhen(Publisher<D> resourceSupplier, Function<? super D,? extends Mono<? extends T>> resourceClosure, Function<? super D,? extends Publisher<?>> asyncCleanup)` Uses a resource, generated by a `Publisher` for each individual `Subscriber`, to derive a `Mono`.
`static <T,D> Mono<T>`	Mono.`usingWhen(Publisher<D> resourceSupplier, Function<? super D,? extends Mono<? extends T>> resourceClosure, Function<? super D,? extends Publisher<?>> asyncComplete, BiFunction<? super D,? super Throwable,? extends Publisher<?>> asyncError, Function<? super D,? extends Publisher<?>> asyncCancel)` Uses a resource, generated by a `Publisher` for each individual `Subscriber`, to derive a `Mono`.Note that all steps of the operator chain that would need the resource to be in an open stable state need to be described inside the `resourceClosure` `Function`.
`static <R> Mono<R>`	Mono.`zip(Iterable<? extends Mono<?>> monos, Function<? super Object[],? extends R> combinator)` Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values according to the provided combinator function.
`static <R> Mono<R>`	Mono.`zipDelayError(Iterable<? extends Mono<?>> monos, Function<? super Object[],? extends R> combinator)` Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item.
`<T2> Mono<Tuple2<T,T2>>`	Mono.`zipWhen(Function<T,Mono<? extends T2>> rightGenerator)` Wait for the result from this mono, use it to create a second mono via the provided `rightGenerator` function and combine both results into a `Tuple2`.
`<T2,O> Mono<O>`	Mono.`zipWhen(Function<T,Mono<? extends T2>> rightGenerator, BiFunction<T,T2,O> combinator)` Wait for the result from this mono, use it to create a second mono via the provided `rightGenerator` function and combine both results into an arbitrary `O` object, as defined by the provided `combinator` function.

Constructors in reactor.core.publisher with parameters of type Mono
Constructor and Description
`MonoOperator(Mono<? extends I> source)` Build a `MonoOperator` wrapper around the passed parent `Publisher`

Uses of Mono in reactor.core.scheduler

Methods in reactor.core.scheduler that return Mono
Modifier and Type	Method and Description
`default Mono<Void>`	Scheduler.`disposeGracefully()` Lazy variant of `Scheduler.dispose()` that also allows for graceful cleanup of underlying resources.

Uses of Mono in reactor.test.publisher

Methods in reactor.test.publisher that return Mono
Modifier and Type	Method and Description
`Mono<T>`	PublisherProbe.`mono()` Return a `Mono` version of the probe.
`Mono<T>`	PublisherProbe.DefaultPublisherProbe.`mono()`
`abstract Mono<T>`	TestPublisher.`mono()` Convenience method to wrap this `TestPublisher` to a `Mono`.

Uses of Mono in reactor.util.retry

Method parameters in reactor.util.retry with type arguments of type Mono
Modifier and Type	Method and Description
`RetrySpec`	RetrySpec.`doAfterRetryAsync(Function<Retry.RetrySignal,Mono<Void>> doAsyncAfterRetry)` Add asynchronous behavior to be executed after the current retry trigger in the companion publisher, thus delaying the resulting retry trigger with the additional `Mono`.
`RetryBackoffSpec`	RetryBackoffSpec.`doAfterRetryAsync(Function<Retry.RetrySignal,Mono<Void>> doAsyncAfterRetry)` Add asynchronous behavior to be executed after the current retry trigger in the companion publisher, thus delaying the resulting retry trigger with the additional `Mono`.
`RetrySpec`	RetrySpec.`doBeforeRetryAsync(Function<Retry.RetrySignal,Mono<Void>> doAsyncBeforeRetry)` Add asynchronous behavior to be executed before the current retry trigger in the companion publisher, thus delaying the resulting retry trigger with the additional `Mono`.
`RetryBackoffSpec`	RetryBackoffSpec.`doBeforeRetryAsync(Function<Retry.RetrySignal,Mono<Void>> doAsyncBeforeRetry)` Add asynchronous behavior to be executed before the current retry trigger in the companion publisher, thus delaying the resulting retry trigger with the additional `Mono`.

Uses of Classreactor.core.publisher.Mono

Uses of Mono in reactor.core.publisher

Uses of Mono in reactor.core.scheduler

Uses of Mono in reactor.test.publisher

Uses of Mono in reactor.util.retry

Uses of Class
reactor.core.publisher.Mono