reactor.core.publisher.MonoProcessor

Aliases

Parameters

reactor.core.publisher.Mono.T

subClasses

superClasses

Any
java.lang.Object
org.reactivestreams.Processor
org.reactivestreams.Publisher
org.reactivestreams.Subscriber
org.reactivestreams.Subscription
reactor.core.CorePublisher
reactor.core.CoreSubscriber
reactor.core.Disposable
reactor.core.Scannable
reactor.core.publisher.Mono

Js Constructors

new reactor_core_publisher_MonoProcessor(
)

ApplyMethods

Methods

$bang$eq(x$1:Any):boolean
$eq$eq(x$1:Any):boolean
$hash$hash():int
actuals():java.util.stream.Stream[reactor.core.Scannable]
and(x$1:org.reactivestreams.Publisher[Any]):reactor.core.publisher.Mono[java.lang.Void]
as(x$1:java.util.function.Function[Anyreactor.core.publisher.Mono.P]):reactor.core.publisher.Mono.P
asInstanceOf():scala.Any.T0
block():reactor.core.publisher.MonoProcessor.O
block(x$1:java.time.Duration):reactor.core.publisher.MonoProcessor.O
blockOptional():java.util.Optional[reactor.core.publisher.Mono.T]
blockOptional(x$1:java.time.Duration):java.util.Optional[reactor.core.publisher.Mono.T]
cache():reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
cache(x$1:java.time.Duration):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
cache(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
cache(x$1:java.util.function.Function[Anyjava.time.Duration], x$2:java.util.function.Function[java.lang.Throwablejava.time.Duration], x$3:java.util.function.Supplier[java.time.Duration]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
cache(x$1:java.util.function.Function[Anyjava.time.Duration], x$2:java.util.function.Function[java.lang.Throwablejava.time.Duration], x$3:java.util.function.Supplier[java.time.Duration], x$4:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
cacheInvalidateIf(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
cacheInvalidateWhen(x$1:java.util.function.Function[Anyreactor.core.publisher.Mono[java.lang.Void]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
cacheInvalidateWhen(x$1:java.util.function.Function[Anyreactor.core.publisher.Mono[java.lang.Void]], x$2:java.util.function.Consumer[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
cancel():Unit
cancelOn(x$1:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
cast(x$1:java.lang.Class[reactor.core.publisher.Mono.E]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.E]
checkpoint():reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
checkpoint(x$1:java.lang.String):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
checkpoint(x$1:java.lang.String, x$2:boolean):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
concatWith(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Mono.T]):reactor.core.publisher.Flux[reactor.core.publisher.Mono.T]
contextWrite(x$1:java.util.function.Function[reactor.util.context.Contextreactor.util.context.Context]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
contextWrite(x$1:reactor.util.context.ContextView):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
currentContext():reactor.util.context.Context
defaultIfEmpty(x$1:reactor.core.publisher.Mono.T):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
delayElement(x$1:java.time.Duration):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
delayElement(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
delaySubscription(x$1:java.time.Duration):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
delaySubscription(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
delaySubscription(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Mono.U]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
delayUntil(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[Any]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
dematerialize():reactor.core.publisher.Mono[reactor.core.publisher.Mono.X]
dispose():Unit
doAfterSuccessOrError(x$1:java.util.function.BiConsumer[Anyjava.lang.Throwable]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doAfterTerminate(x$1:java.lang.Runnable):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doFinally(x$1:java.util.function.Consumer[reactor.core.publisher.SignalType]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doFirst(x$1:java.lang.Runnable):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doOnCancel(x$1:java.lang.Runnable):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doOnDiscard(x$1:java.lang.Class[reactor.core.publisher.Mono.R], x$2:java.util.function.Consumer[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doOnEach(x$1:java.util.function.Consumer[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doOnError(x$1:java.lang.Class[reactor.core.publisher.Mono.E], x$2:java.util.function.Consumer[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doOnError(x$1:java.util.function.Consumer[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doOnError(x$1:java.util.function.Predicate[Any], x$2:java.util.function.Consumer[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doOnNext(x$1:java.util.function.Consumer[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doOnRequest(x$1:java.util.function.LongConsumer):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doOnSubscribe(x$1:java.util.function.Consumer[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doOnSuccess(x$1:java.util.function.Consumer[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doOnSuccessOrError(x$1:java.util.function.BiConsumer[Anyjava.lang.Throwable]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
doOnTerminate(x$1:java.lang.Runnable):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
downstreamCount():long
elapsed():reactor.core.publisher.Mono[reactor.util.function.Tuple2[java.lang.Longreactor.core.publisher.Mono.T]]
elapsed(x$1:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.util.function.Tuple2[java.lang.Longreactor.core.publisher.Mono.T]]
eq(x$1:java.lang.Object):boolean
equals(x$1:Any):boolean
expand(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Mono.T]]):reactor.core.publisher.Flux[reactor.core.publisher.Mono.T]
expand(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Mono.T]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Mono.T]
expandDeep(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Mono.T]]):reactor.core.publisher.Flux[reactor.core.publisher.Mono.T]
expandDeep(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Mono.T]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Mono.T]
filter(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
filterWhen(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[java.lang.Boolean]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
flatMap(x$1:java.util.function.Function[Anyreactor.core.publisher.Mono[reactor.core.publisher.Mono.R]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.R]
flatMapIterable(x$1:java.util.function.Function[Anyjava.lang.Iterable[reactor.core.publisher.Mono.R]]):reactor.core.publisher.Flux[reactor.core.publisher.Mono.R]
flatMapMany(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Mono.R]]):reactor.core.publisher.Flux[reactor.core.publisher.Mono.R]
flatMapMany(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Mono.R]], x$2:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Mono.R]], x$3:java.util.function.Supplier[org.reactivestreams.Publisher[reactor.core.publisher.Mono.R]]):reactor.core.publisher.Flux[reactor.core.publisher.Mono.R]
flux():reactor.core.publisher.Flux[reactor.core.publisher.Mono.T]
getClass():java.lang.Class[Any]
getError():java.lang.Throwable
handle(x$1:java.util.function.BiConsumer[Anyreactor.core.publisher.SynchronousSink[reactor.core.publisher.Mono.R]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.R]
hasDownstreams():boolean
hasElement():reactor.core.publisher.Mono[java.lang.Boolean]
hashCode():int
hide():reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
ignoreElement():reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
inners():java.util.stream.Stream[reactor.core.Scannable]
isCancelled():boolean
isDisposed():boolean
isError():boolean
isInstanceOf():boolean
isScanAvailable():boolean
isSuccess():boolean
isTerminated():boolean
log():reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
log(x$1:java.lang.String):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
log(x$1:java.lang.String, x$2:java.util.logging.Level, x$3:UnknownNothing):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
log(x$1:java.lang.String, x$2:java.util.logging.Level, x$3:boolean, x$4:UnknownNothing):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
log(x$1:reactor.util.Logger):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
log(x$1:reactor.util.Logger, x$2:java.util.logging.Level, x$3:boolean, x$4:UnknownNothing):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
map(x$1:java.util.function.Function[Anyreactor.core.publisher.Mono.R]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.R]
mapNotNull(x$1:java.util.function.Function[Anyreactor.core.publisher.Mono.R]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.R]
materialize():reactor.core.publisher.Mono[reactor.core.publisher.Signal[reactor.core.publisher.Mono.T]]
mergeWith(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Mono.T]):reactor.core.publisher.Flux[reactor.core.publisher.Mono.T]
metrics():reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
name():java.lang.String
name(x$1:java.lang.String):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
ne(x$1:java.lang.Object):boolean
notify():Unit
notifyAll():Unit
ofType(x$1:java.lang.Class[reactor.core.publisher.Mono.U]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.U]
onComplete():Unit
onError(x$1:java.lang.Throwable):Unit
onErrorComplete():reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorComplete(x$1:java.lang.Class[java.lang.Throwable]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorComplete(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorContinue(x$1:java.lang.Class[reactor.core.publisher.Mono.E], x$2:java.util.function.BiConsumer[java.lang.Objectjava.lang.Throwable]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorContinue(x$1:java.util.function.BiConsumer[java.lang.Objectjava.lang.Throwable]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorContinue(x$1:java.util.function.Predicate[reactor.core.publisher.Mono.E], x$2:java.util.function.BiConsumer[java.lang.Objectjava.lang.Throwable]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorMap(x$1:java.lang.Class[reactor.core.publisher.Mono.E], x$2:java.util.function.Function[Anyjava.lang.Throwable]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorMap(x$1:java.util.function.Function[Anyjava.lang.Throwable]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorMap(x$1:java.util.function.Predicate[Any], x$2:java.util.function.Function[Anyjava.lang.Throwable]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorResume(x$1:java.lang.Class[reactor.core.publisher.Mono.E], x$2:java.util.function.Function[Anyreactor.core.publisher.Mono[reactor.core.publisher.Mono.T]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorResume(x$1:java.util.function.Function[Anyreactor.core.publisher.Mono[reactor.core.publisher.Mono.T]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorResume(x$1:java.util.function.Predicate[Any], x$2:java.util.function.Function[Anyreactor.core.publisher.Mono[reactor.core.publisher.Mono.T]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorReturn(x$1:java.lang.Class[reactor.core.publisher.Mono.E], x$2:reactor.core.publisher.Mono.T):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorReturn(x$1:java.util.function.Predicate[Any], x$2:reactor.core.publisher.Mono.T):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorReturn(x$1:reactor.core.publisher.Mono.T):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onErrorStop():reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
onNext(x$1:org.reactivestreams.Subscriber.T):Unit
onSubscribe(x$1:org.reactivestreams.Subscription):Unit
onTerminateDetach():reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
or(x$1:reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
parents():java.util.stream.Stream[reactor.core.Scannable]
peek():reactor.core.publisher.MonoProcessor.O
publish(x$1:java.util.function.Function[Anyreactor.core.publisher.Mono[reactor.core.publisher.Mono.R]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.R]
publishOn(x$1:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
repeat():reactor.core.publisher.Flux[reactor.core.publisher.Mono.T]
repeat(x$1:java.util.function.BooleanSupplier):reactor.core.publisher.Flux[reactor.core.publisher.Mono.T]
repeat(x$1:long):reactor.core.publisher.Flux[reactor.core.publisher.Mono.T]
repeat(x$1:long, x$2:java.util.function.BooleanSupplier):reactor.core.publisher.Flux[reactor.core.publisher.Mono.T]
repeatWhen(x$1:java.util.function.Function[org.reactivestreams.Publisher[Any]reactor.core.publisher.Flux[java.lang.Long]]):reactor.core.publisher.Flux[reactor.core.publisher.Mono.T]
repeatWhenEmpty(x$1:int, x$2:java.util.function.Function[org.reactivestreams.Publisher[Any]reactor.core.publisher.Flux[java.lang.Long]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
repeatWhenEmpty(x$1:java.util.function.Function[org.reactivestreams.Publisher[Any]reactor.core.publisher.Flux[java.lang.Long]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
request(x$1:long):Unit
retry():reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
retry(x$1:long):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
retryWhen(x$1:reactor.util.retry.Retry):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
scan(x$1:reactor.core.Scannable$Attr[reactor.core.Scannable.T]):reactor.core.Scannable.T
scanOrDefault(x$1:reactor.core.Scannable$Attr[reactor.core.Scannable.T], x$2:reactor.core.Scannable.T):reactor.core.Scannable.T
scanUnsafe(x$1:reactor.core.Scannable$Attr[Any]):java.lang.Object
share():reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
single():reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
stepName():java.lang.String
steps():java.util.stream.Stream[java.lang.String]
subscribe(x$1:org.reactivestreams.Subscriber[Any]):Unit
subscribe(x$1:reactor.core.CoreSubscriber[Any]):Unit
subscribe():reactor.core.Disposable
subscribe(x$1:java.util.function.Consumer[Any]):reactor.core.Disposable
subscribe(x$1:java.util.function.Consumer[Any], x$2:java.util.function.Consumer[Any]):reactor.core.Disposable
subscribe(x$1:java.util.function.Consumer[Any], x$2:java.util.function.Consumer[Any], x$3:java.lang.Runnable):reactor.core.Disposable
subscribe(x$1:java.util.function.Consumer[Any], x$2:java.util.function.Consumer[Any], x$3:java.lang.Runnable, x$4:java.util.function.Consumer[Any]):reactor.core.Disposable
subscribe(x$1:java.util.function.Consumer[Any], x$2:java.util.function.Consumer[Any], x$3:java.lang.Runnable, x$4:reactor.util.context.Context):reactor.core.Disposable
subscribeOn(x$1:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
subscribeWith(x$1:reactor.core.publisher.Mono.E):reactor.core.publisher.Mono.E
subscriberContext(x$1:java.util.function.Function[reactor.util.context.Contextreactor.util.context.Context]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
subscriberContext(x$1:reactor.util.context.Context):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
switchIfEmpty(x$1:reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
synchronized(x$1:java.lang.Object.T0):java.lang.Object.T0
tag(x$1:java.lang.String, x$2:java.lang.String):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
tags():java.util.stream.Stream[reactor.util.function.Tuple2[java.lang.Stringjava.lang.String]]
take(x$1:java.time.Duration):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
take(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
takeUntilOther(x$1:org.reactivestreams.Publisher[Any]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
then():reactor.core.publisher.Mono[java.lang.Void]
then(x$1:reactor.core.publisher.Mono[reactor.core.publisher.Mono.V]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.V]
thenEmpty(x$1:org.reactivestreams.Publisher[java.lang.Void]):reactor.core.publisher.Mono[java.lang.Void]
thenMany(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Mono.V]):reactor.core.publisher.Flux[reactor.core.publisher.Mono.V]
thenReturn(x$1:reactor.core.publisher.Mono.V):reactor.core.publisher.Mono[reactor.core.publisher.Mono.V]
timed():reactor.core.publisher.Mono[reactor.core.publisher.Timed[reactor.core.publisher.Mono.T]]
timed(x$1:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.core.publisher.Timed[reactor.core.publisher.Mono.T]]
timeout(x$1:java.time.Duration):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
timeout(x$1:java.time.Duration, x$2:reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
timeout(x$1:java.time.Duration, x$2:reactor.core.publisher.Mono[reactor.core.publisher.Mono.T], x$3:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
timeout(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
timeout(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Mono.U]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
timeout(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Mono.U], x$2:reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.T]
timestamp():reactor.core.publisher.Mono[reactor.util.function.Tuple2[java.lang.Longreactor.core.publisher.Mono.T]]
timestamp(x$1:reactor.core.scheduler.Scheduler):reactor.core.publisher.Mono[reactor.util.function.Tuple2[java.lang.Longreactor.core.publisher.Mono.T]]
toFuture():java.util.concurrent.CompletableFuture[reactor.core.publisher.Mono.T]
toProcessor():reactor.core.publisher.MonoProcessor[reactor.core.publisher.Mono.T]
toString():java.lang.String
transform(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Mono.V]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.V]
transformDeferred(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Mono.V]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.V]
transformDeferredContextual(x$1:java.util.function.BiFunction[AnyAnyorg.reactivestreams.Publisher[reactor.core.publisher.Mono.V]]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.V]
wait():Unit
wait(x$1:long):Unit
wait(x$1:long, x$2:int):Unit
zipWhen(x$1:java.util.function.Function[reactor.core.publisher.Mono[reactor.core.publisher.Mono.T2]reactor.core.publisher.Mono.T]):reactor.core.publisher.Mono[reactor.util.function.Tuple2[reactor.core.publisher.Mono.Treactor.core.publisher.Mono.T2]]
zipWhen(x$1:java.util.function.Function[reactor.core.publisher.Mono[reactor.core.publisher.Mono.T2]reactor.core.publisher.Mono.T], x$2:java.util.function.BiFunction[reactor.core.publisher.Mono.Oreactor.core.publisher.Mono.Treactor.core.publisher.Mono.T2]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.O]
zipWith(x$1:reactor.core.publisher.Mono[reactor.core.publisher.Mono.T2]):reactor.core.publisher.Mono[reactor.util.function.Tuple2[reactor.core.publisher.Mono.Treactor.core.publisher.Mono.T2]]
zipWith(x$1:reactor.core.publisher.Mono[reactor.core.publisher.Mono.T2], x$2:java.util.function.BiFunction[AnyAnyreactor.core.publisher.Mono.O]):reactor.core.publisher.Mono[reactor.core.publisher.Mono.O]