fun <R : Any> flatMapMany(p0: Function<in Void, out Publisher<out R>>, p1: Function<in Throwable, out Publisher<out R>>, p2: Supplier<out Publisher<out R>>): Flux<R>

flux

fun flux(): Flux<Void>

handle

fun <R : Any> handle(p0: BiConsumer<in Void, SynchronousSink<R>>): Mono<R>

hasElement

fun hasElement(): Mono<Boolean>

hide

fun hide(): Mono<Void>

ignoreElement

fun ignoreElement(): Mono<Void>

log

fun log(): Mono<Void>

fun log(@Nullable p0: String): Mono<Void>

fun log(p0: Logger): Mono<Void>

fun log(@Nullable p0: String, p1: Level, vararg p2: SignalType): Mono<Void>

fun log(@Nullable p0: String, p1: Level, p2: Boolean, vararg p3: SignalType): Mono<Void>

fun log(p0: Logger, p1: Level, p2: Boolean, vararg p3: SignalType): Mono<Void>

logErrorResume

fun <T : Any> Mono<T>.logErrorResume(): Mono<T>

map

fun <R : Any> map(p0: Function<in Void, out R>): Mono<R>

mapNotNull

fun <R : Any> mapNotNull(p0: Function<in Void, out R>): Mono<R>

materialize

fun materialize(): Mono<Signal<Void>>

mergeWith

fun mergeWith(p0: Publisher<out Void>): Flux<Void>

metrics

fun ~~metrics~~(): Mono<Void>

name

fun name(p0: String): Mono<Void>

ofType

fun ofType(p0: Class): Mono

onErrorComplete

fun onErrorComplete(): Mono<Void>

fun onErrorComplete(p0: Class<out Throwable>): Mono<Void>

fun onErrorComplete(p0: Predicate<in Throwable>): Mono<Void>

onErrorContinue

fun onErrorContinue(p0: BiConsumer<Throwable, Any>): Mono<Void>

fun <E : Throwable> onErrorContinue(p0: Class<E>, p1: BiConsumer<Throwable, Any>): Mono<Void>

fun <E : Throwable> onErrorContinue(p0: Predicate<E>, p1: BiConsumer<Throwable, Any>): Mono<Void>

onErrorMap

fun onErrorMap(p0: Function<in Throwable, out Throwable>): Mono<Void>

fun <E : Throwable> onErrorMap(p0: Class<E>, p1: Function<in E, out Throwable>): Mono<Void>

fun onErrorMap(p0: Predicate<in Throwable>, p1: Function<in Throwable, out Throwable>): Mono<Void>

onErrorResume

fun onErrorResume(p0: Function<in Throwable, out Mono<out Void>>): Mono<Void>

fun <E : Throwable> onErrorResume(p0: Class<E>, p1: Function<in E, out Mono<out Void>>): Mono<Void>

fun onErrorResume(p0: Predicate<in Throwable>, p1: Function<in Throwable, out Mono<out Void>>): Mono<Void>

onErrorReturn

fun onErrorReturn(p0: Void): Mono<Void>

fun <E : Throwable> onErrorReturn(p0: Class<E>, p1: Void): Mono<Void>

fun onErrorReturn(p0: Predicate<in Throwable>, p1: Void): Mono<Void>

onErrorStop

fun onErrorStop(): Mono<Void>

onTerminateDetach

fun onTerminateDetach(): Mono<Void>

fun or(p0: Mono<out Void>): Mono<Void>

publish

fun <R : Any> publish(p0: Function<in Mono<Void>, out Mono<out R>>): Mono<R>

publishOn

fun publishOn(p0: Scheduler): Mono<Void>

repeat

fun repeat(): Flux<Void>

fun repeat(p0: BooleanSupplier): Flux<Void>

fun repeat(p0: Long): Flux<Void>

fun repeat(p0: Long, p1: BooleanSupplier): Flux<Void>

repeatWhen

fun repeatWhen(p0: Function<Flux<Long>, out Publisher<*>>): Flux<Void>

repeatWhenEmpty

fun repeatWhenEmpty(p0: Function<Flux<Long>, out Publisher<*>>): Mono<Void>

fun repeatWhenEmpty(p0: Int, p1: Function<Flux<Long>, out Publisher<*>>): Mono<Void>

retry

fun retry(): Mono<Void>

fun retry(p0: Long): Mono<Void>

retryWhen

fun retryWhen(p0: Retry): Mono<Void>

fun share(): Mono<Void>

single

fun single(): Mono<Void>

singleOptional

fun singleOptional(): Mono<Optional<Void>>

open override fun subscribe(actual: CoreSubscriber<in Void>)

fun subscribe(): Disposable

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

override fun subscribe(p0: Subscriber<in Void>)

fun subscribe(@Nullable p0: Consumer<in Void>, p1: Consumer<in Throwable>): Disposable

fun subscribe(@Nullable p0: Consumer<in Void>, @Nullable p1: Consumer<in Throwable>, @Nullable p2: Runnable): Disposable

fun subscribe(@Nullable p0: Consumer<in Void>, @Nullable p1: Consumer<in Throwable>, @Nullable p2: Runnable, @Nullable p3: Consumer<in Subscription>): Disposable

fun subscribe(@Nullable p0: Consumer<in Void>, @Nullable p1: Consumer<in Throwable>, @Nullable p2: Runnable, @Nullable p3: Context): Disposable

subscribeOn

fun subscribeOn(p0: Scheduler): Mono<Void>

subscribeWith

fun <E : Subscriber<in Void>> subscribeWith(p0: E): E

switchIfEmpty

fun switchIfEmpty(p0: Mono<out Void>): Mono<Void>

tag

fun tag(p0: String, p1: String): Mono<Void>

tagSource

fun <M> Mono<M>.tagSource(source: String): Mono<M>

take

fun take(p0: Duration): Mono<Void>

fun take(p0: Duration, p1: Scheduler): Mono<Void>

takeUntilOther

fun takeUntilOther(p0: Publisher<*>): Mono<Void>

tap

fun tap(p0: Function<ContextView, SignalListener<Void>>): Mono<Void>

fun tap(p0: Supplier<SignalListener<Void>>): Mono<Void>

fun tap(p0: SignalListenerFactory<Void, *>): Mono<Void>

then

fun then(): Mono<Void>

fun <V : Any> then(p0: Mono<V>): Mono<V>

thenEmpty

fun thenEmpty(p0: Publisher<Void>): Mono<Void>

thenMany

fun <V : Any> thenMany(p0: Publisher<V>): Flux<V>

thenNotifyAndForget

fun <E : MessageExchange<*, M>, M : Message<*, *>, CommandId, NamedBoundedContext> Mono<Void>.thenNotifyAndForget(commandWaitNotifier: CommandWaitNotifier, processingStage: CommandStage, messageExchange: E): Mono<Void>

thenReturn

fun <V : Any> thenReturn(p0: V): Mono<V>

throwNotFoundIfEmpty

fun <T> Mono<T>.throwNotFoundIfEmpty(errorMsg: String = ErrorCodes.NOT_FOUND_MESSAGE): Mono<T>

timed

fun timed(): Mono<Timed<Void>>

fun timed(p0: Scheduler): Mono<Timed<Void>>

timeout

fun timeout(p0: Duration): Mono<Void>

fun timeout(p0: Publisher): Mono<Void>

fun timeout(p0: Duration, p1: Mono<out Void>): Mono<Void>

fun timeout(p0: Duration, p1: Scheduler): Mono<Void>

fun timeout(p0: Publisher, p1: Mono<out Void>): Mono<Void>

fun timeout(p0: Duration, @Nullable p1: Mono<out Void>, p2: Scheduler): Mono<Void>

timestamp

fun timestamp(): Mono<Tuple2<Long, Void>>

fun timestamp(p0: Scheduler): Mono<Tuple2<Long, Void>>

toBlockable

fun <T> Mono<T>.toBlockable(scheduler: Scheduler = Schedulers.boundedElastic()): Mono<T>

toFuture

fun toFuture(): CompletableFuture<Void>

toString

open override fun toString(): String

transform

fun <V : Any> transform(p0: Function<in Mono<Void>, out Publisher<V>>): Mono<V>

transformDeferred

fun <V : Any> transformDeferred(p0: Function<in Mono<Void>, out Publisher<V>>): Mono<V>

transformDeferredContextual

fun <V : Any> transformDeferredContextual(p0: BiFunction<in Mono<Void>, in ContextView, out Publisher<V>>): Mono<V>

zipWhen

fun <T2 : Any> zipWhen(p0: Function<Void, Mono<out T2>>): Mono<Tuple2<Void, T2>>

fun <T2 : Any, O : Any> zipWhen(p0: Function<Void, Mono<out T2>>, p1: BiFunction<Void, T2, O>): Mono<O>

zipWith

fun <T2 : Any> zipWith(p0: Mono<out T2>): Mono<Tuple2<Void, T2>>

fun <T2 : Any, O : Any> zipWith(p0: Mono<out T2>, p1: BiFunction<in Void, in T2, out O>): Mono<O>