Parameters

java.lang.Integer, reactor.core.publisher.ParallelFlux.T

subClasses

superClasses

Any

java.lang.Object

org.reactivestreams.Publisher

reactor.core.CorePublisher

reactor.core.publisher.Flux

Js Constructors

new reactor_core_publisher_GroupedFlux(
)

ApplyMethods

Methods

$bang$eq(x$1:Any):boolean

$eq$eq(x$1:Any):boolean

$hash$hash():int

all(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Mono[java.lang.Boolean]

any(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Mono[java.lang.Boolean]

as(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.P]):reactor.core.publisher.Flux.P

asInstanceOf():scala.Any.T0

blockFirst():reactor.core.publisher.Flux.T

blockFirst(x$1:java.time.Duration):reactor.core.publisher.Flux.T

blockLast():reactor.core.publisher.Flux.T

blockLast(x$1:java.time.Duration):reactor.core.publisher.Flux.T

buffer():reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

buffer(x$1:int):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

buffer(x$1:int, x$2:int):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

buffer(x$1:int, x$2:int, x$3:java.util.function.Supplier[reactor.core.publisher.Flux.C]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.C]

buffer(x$1:int, x$2:java.util.function.Supplier[reactor.core.publisher.Flux.C]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.C]

buffer(x$1:java.time.Duration):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

buffer(x$1:java.time.Duration, x$2:java.time.Duration):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

buffer(x$1:java.time.Duration, x$2:java.time.Duration, x$3:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

buffer(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

buffer(x$1:org.reactivestreams.Publisher[Any]):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

buffer(x$1:org.reactivestreams.Publisher[Any], x$2:java.util.function.Supplier[reactor.core.publisher.Flux.C]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.C]

bufferTimeout(x$1:int, x$2:java.time.Duration):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

bufferTimeout(x$1:int, x$2:java.time.Duration, x$3:java.util.function.Supplier[reactor.core.publisher.Flux.C]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.C]

bufferTimeout(x$1:int, x$2:java.time.Duration, x$3:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

bufferTimeout(x$1:int, x$2:java.time.Duration, x$3:reactor.core.scheduler.Scheduler, x$4:java.util.function.Supplier[reactor.core.publisher.Flux.C]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.C]

bufferUntil(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

bufferUntil(x$1:java.util.function.Predicate[Any], x$2:boolean):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

bufferUntilChanged():reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

bufferUntilChanged(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.V]):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

bufferUntilChanged(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.V], x$2:java.util.function.BiPredicate[AnyAny]):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

bufferWhen(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.U], x$2:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]]):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

bufferWhen(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.U], x$2:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]], x$3:java.util.function.Supplier[reactor.core.publisher.Flux.C]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.C]

bufferWhile(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Flux[java.util.List[reactor.core.publisher.Flux.T]]

cache():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

cache(x$1:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

cache(x$1:int, x$2:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

cache(x$1:int, x$2:java.time.Duration, x$3:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

cache(x$1:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

cache(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

cancelOn(x$1:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

cast(x$1:java.lang.Class[reactor.core.publisher.Flux.E]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.E]

checkpoint():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

checkpoint(x$1:java.lang.String):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

checkpoint(x$1:java.lang.String, x$2:boolean):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

collect(x$1:java.util.function.Supplier[reactor.core.publisher.Flux.E], x$2:java.util.function.BiConsumer[Anyreactor.core.publisher.Flux.E]):reactor.core.publisher.Mono[reactor.core.publisher.Flux.E]

collect(x$1:java.util.stream.Collector[Anyreactor.core.publisher.Flux.Areactor.core.publisher.Flux.R]):reactor.core.publisher.Mono[reactor.core.publisher.Flux.R]

collectList():reactor.core.publisher.Mono[java.util.List[reactor.core.publisher.Flux.T]]

collectMap(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.K]):reactor.core.publisher.Mono[java.util.Map[reactor.core.publisher.Flux.Kreactor.core.publisher.Flux.T]]

collectMap(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.K], x$2:java.util.function.Function[Anyreactor.core.publisher.Flux.V]):reactor.core.publisher.Mono[java.util.Map[reactor.core.publisher.Flux.Kreactor.core.publisher.Flux.V]]

collectMap(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.K], x$2:java.util.function.Function[Anyreactor.core.publisher.Flux.V], x$3:java.util.function.Supplier[java.util.Map[reactor.core.publisher.Flux.Kreactor.core.publisher.Flux.V]]):reactor.core.publisher.Mono[java.util.Map[reactor.core.publisher.Flux.Kreactor.core.publisher.Flux.V]]

collectMultimap(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.K]):reactor.core.publisher.Mono[java.util.Map[java.util.Collection[reactor.core.publisher.Flux.T]reactor.core.publisher.Flux.K]]

collectMultimap(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.K], x$2:java.util.function.Function[Anyreactor.core.publisher.Flux.V]):reactor.core.publisher.Mono[java.util.Map[java.util.Collection[reactor.core.publisher.Flux.V]reactor.core.publisher.Flux.K]]

collectMultimap(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.K], x$2:java.util.function.Function[Anyreactor.core.publisher.Flux.V], x$3:java.util.function.Supplier[java.util.Map[java.util.Collection[reactor.core.publisher.Flux.V]reactor.core.publisher.Flux.K]]):reactor.core.publisher.Mono[java.util.Map[java.util.Collection[reactor.core.publisher.Flux.V]reactor.core.publisher.Flux.K]]

collectSortedList():reactor.core.publisher.Mono[java.util.List[reactor.core.publisher.Flux.T]]

collectSortedList(x$1:java.util.Comparator[Any]):reactor.core.publisher.Mono[java.util.List[reactor.core.publisher.Flux.T]]

concatMap(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

concatMap(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

concatMapDelayError(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

concatMapDelayError(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]], x$2:boolean, x$3:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

concatMapDelayError(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

concatMapIterable(x$1:java.util.function.Function[Anyjava.lang.Iterable[reactor.core.publisher.Flux.R]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

concatMapIterable(x$1:java.util.function.Function[Anyjava.lang.Iterable[reactor.core.publisher.Flux.R]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

concatWith(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

concatWithValues(x$1:Unknown Nothing):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

contextWrite(x$1:java.util.function.Function[reactor.util.context.Contextreactor.util.context.Context]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

contextWrite(x$1:reactor.util.context.ContextView):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

count():reactor.core.publisher.Mono[java.lang.Long]

defaultIfEmpty(x$1:reactor.core.publisher.Flux.T):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

delayElements(x$1:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

delayElements(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

delaySequence(x$1:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

delaySequence(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

delaySubscription(x$1:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

delaySubscription(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

delaySubscription(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.U]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

delayUntil(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[Any]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

dematerialize():reactor.core.publisher.Flux[reactor.core.publisher.Flux.X]

distinct():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

distinct(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.V]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

distinct(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.V], x$2:java.util.function.Supplier[reactor.core.publisher.Flux.C]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

distinct(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.V], x$2:java.util.function.Supplier[reactor.core.publisher.Flux.C], x$3:java.util.function.BiPredicate[reactor.core.publisher.Flux.Creactor.core.publisher.Flux.V], x$4:java.util.function.Consumer[reactor.core.publisher.Flux.C]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

distinctUntilChanged():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

distinctUntilChanged(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.V]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

distinctUntilChanged(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.V], x$2:java.util.function.BiPredicate[AnyAny]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doAfterTerminate(x$1:java.lang.Runnable):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doFinally(x$1:java.util.function.Consumer[reactor.core.publisher.SignalType]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doFirst(x$1:java.lang.Runnable):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doOnCancel(x$1:java.lang.Runnable):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doOnComplete(x$1:java.lang.Runnable):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doOnDiscard(x$1:java.lang.Class[reactor.core.publisher.Flux.R], x$2:java.util.function.Consumer[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doOnEach(x$1:java.util.function.Consumer[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doOnError(x$1:java.lang.Class[reactor.core.publisher.Flux.E], x$2:java.util.function.Consumer[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doOnError(x$1:java.util.function.Consumer[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doOnError(x$1:java.util.function.Predicate[Any], x$2:java.util.function.Consumer[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doOnNext(x$1:java.util.function.Consumer[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doOnRequest(x$1:java.util.function.LongConsumer):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doOnSubscribe(x$1:java.util.function.Consumer[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

doOnTerminate(x$1:java.lang.Runnable):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

elapsed():reactor.core.publisher.Flux[reactor.util.function.Tuple2[java.lang.Longreactor.core.publisher.Flux.T]]

elapsed(x$1:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.util.function.Tuple2[java.lang.Longreactor.core.publisher.Flux.T]]

elementAt(x$1:int):reactor.core.publisher.Mono[reactor.core.publisher.Flux.T]

elementAt(x$1:int, x$2:reactor.core.publisher.Flux.T):reactor.core.publisher.Mono[reactor.core.publisher.Flux.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.Flux.T]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

expand(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.T]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

expandDeep(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.T]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

expandDeep(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.T]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

filter(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

filterWhen(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[java.lang.Boolean]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

filterWhen(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[java.lang.Boolean]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

flatMap(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.R]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

flatMap(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

flatMap(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]], x$2:int, x$3:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

flatMap(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.R]], x$2:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.R]], x$3:java.util.function.Supplier[org.reactivestreams.Publisher[reactor.core.publisher.Flux.R]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

flatMapDelayError(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]], x$2:int, x$3:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

flatMapIterable(x$1:java.util.function.Function[Anyjava.lang.Iterable[reactor.core.publisher.Flux.R]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

flatMapIterable(x$1:java.util.function.Function[Anyjava.lang.Iterable[reactor.core.publisher.Flux.R]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

flatMapSequential(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.R]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

flatMapSequential(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.R]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

flatMapSequential(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.R]], x$2:int, x$3:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

flatMapSequentialDelayError(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.R]], x$2:int, x$3:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

getClass():java.lang.Class[Any]

getPrefetch():int

groupBy(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.K]):reactor.core.publisher.Flux[reactor.core.publisher.GroupedFlux[reactor.core.publisher.Flux.Kreactor.core.publisher.Flux.T]]

groupBy(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.K], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.GroupedFlux[reactor.core.publisher.Flux.Kreactor.core.publisher.Flux.T]]

groupBy(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.K], x$2:java.util.function.Function[Anyreactor.core.publisher.Flux.V]):reactor.core.publisher.Flux[reactor.core.publisher.GroupedFlux[reactor.core.publisher.Flux.Kreactor.core.publisher.Flux.V]]

groupBy(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.K], x$2:java.util.function.Function[Anyreactor.core.publisher.Flux.V], x$3:int):reactor.core.publisher.Flux[reactor.core.publisher.GroupedFlux[reactor.core.publisher.Flux.Kreactor.core.publisher.Flux.V]]

handle(x$1:java.util.function.BiConsumer[Anyreactor.core.publisher.SynchronousSink[reactor.core.publisher.Flux.R]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

hasElement(x$1:reactor.core.publisher.Flux.T):reactor.core.publisher.Mono[java.lang.Boolean]

hasElements():reactor.core.publisher.Mono[java.lang.Boolean]

hashCode():int

hide():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

ignoreElements():reactor.core.publisher.Mono[reactor.core.publisher.Flux.T]

index():reactor.core.publisher.Flux[reactor.util.function.Tuple2[java.lang.Longreactor.core.publisher.Flux.T]]

index(x$1:java.util.function.BiFunction[AnyAnyreactor.core.publisher.Flux.I]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.I]

isInstanceOf():boolean

key():reactor.core.publisher.GroupedFlux.K

last():reactor.core.publisher.Mono[reactor.core.publisher.Flux.T]

last(x$1:reactor.core.publisher.Flux.T):reactor.core.publisher.Mono[reactor.core.publisher.Flux.T]

limitRate(x$1:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

limitRate(x$1:int, x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

limitRequest(x$1:long):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

log():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

log(x$1:java.lang.String):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

log(x$1:java.lang.String, x$2:java.util.logging.Level, x$3:Unknown Nothing):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

log(x$1:java.lang.String, x$2:java.util.logging.Level, x$3:boolean, x$4:Unknown Nothing):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

log(x$1:reactor.util.Logger):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

log(x$1:reactor.util.Logger, x$2:java.util.logging.Level, x$3:boolean, x$4:Unknown Nothing):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

map(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.V]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

mapNotNull(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.V]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

materialize():reactor.core.publisher.Flux[reactor.core.publisher.Signal[reactor.core.publisher.Flux.T]]

mergeComparingWith(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T], x$2:java.util.Comparator[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

mergeOrderedWith(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T], x$2:java.util.Comparator[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

mergeWith(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

metrics():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

name(x$1:java.lang.String):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

ne(x$1:java.lang.Object):boolean

next():reactor.core.publisher.Mono[reactor.core.publisher.Flux.T]

notify():Unit

notifyAll():Unit

ofType(x$1:java.lang.Class[reactor.core.publisher.Flux.U]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.U]

onBackpressureBuffer():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onBackpressureBuffer(x$1:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onBackpressureBuffer(x$1:int, x$2:java.util.function.Consumer[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onBackpressureBuffer(x$1:int, x$2:java.util.function.Consumer[Any], x$3:reactor.core.publisher.BufferOverflowStrategy):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onBackpressureBuffer(x$1:int, x$2:reactor.core.publisher.BufferOverflowStrategy):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onBackpressureBuffer(x$1:java.time.Duration, x$2:int, x$3:java.util.function.Consumer[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onBackpressureBuffer(x$1:java.time.Duration, x$2:int, x$3:java.util.function.Consumer[Any], x$4:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onBackpressureDrop():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onBackpressureDrop(x$1:java.util.function.Consumer[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onBackpressureError():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onBackpressureLatest():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorComplete():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorComplete(x$1:java.lang.Class[java.lang.Throwable]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorComplete(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorContinue(x$1:java.lang.Class[reactor.core.publisher.Flux.E], x$2:java.util.function.BiConsumer[java.lang.Objectjava.lang.Throwable]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorContinue(x$1:java.util.function.BiConsumer[java.lang.Objectjava.lang.Throwable]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorContinue(x$1:java.util.function.Predicate[reactor.core.publisher.Flux.E], x$2:java.util.function.BiConsumer[java.lang.Objectjava.lang.Throwable]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorMap(x$1:java.lang.Class[reactor.core.publisher.Flux.E], x$2:java.util.function.Function[Anyjava.lang.Throwable]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorMap(x$1:java.util.function.Function[Anyjava.lang.Throwable]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorMap(x$1:java.util.function.Predicate[Any], x$2:java.util.function.Function[Anyjava.lang.Throwable]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorResume(x$1:java.lang.Class[reactor.core.publisher.Flux.E], x$2:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.T]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorResume(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.T]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorResume(x$1:java.util.function.Predicate[Any], x$2:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.T]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorReturn(x$1:java.lang.Class[reactor.core.publisher.Flux.E], x$2:reactor.core.publisher.Flux.T):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorReturn(x$1:java.util.function.Predicate[Any], x$2:reactor.core.publisher.Flux.T):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorReturn(x$1:reactor.core.publisher.Flux.T):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onErrorStop():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

onTerminateDetach():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

or(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

parallel():reactor.core.publisher.ParallelFlux[reactor.core.publisher.Flux.T]

parallel(x$1:int):reactor.core.publisher.ParallelFlux[reactor.core.publisher.Flux.T]

parallel(x$1:int, x$2:int):reactor.core.publisher.ParallelFlux[reactor.core.publisher.Flux.T]

publish():reactor.core.publisher.ConnectableFlux[reactor.core.publisher.Flux.T]

publish(x$1:int):reactor.core.publisher.ConnectableFlux[reactor.core.publisher.Flux.T]

publish(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.R]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

publish(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.R]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

publishNext():reactor.core.publisher.Mono[reactor.core.publisher.Flux.T]

publishOn(x$1:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

publishOn(x$1:reactor.core.scheduler.Scheduler, x$2:boolean, x$3:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

publishOn(x$1:reactor.core.scheduler.Scheduler, x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

reduce(x$1:java.util.function.BiFunction[reactor.core.publisher.Flux.Treactor.core.publisher.Flux.Treactor.core.publisher.Flux.T]):reactor.core.publisher.Mono[reactor.core.publisher.Flux.T]

reduce(x$1:reactor.core.publisher.Flux.A, x$2:java.util.function.BiFunction[Anyreactor.core.publisher.Flux.Areactor.core.publisher.Flux.A]):reactor.core.publisher.Mono[reactor.core.publisher.Flux.A]

reduceWith(x$1:java.util.function.Supplier[reactor.core.publisher.Flux.A], x$2:java.util.function.BiFunction[Anyreactor.core.publisher.Flux.Areactor.core.publisher.Flux.A]):reactor.core.publisher.Mono[reactor.core.publisher.Flux.A]

repeat():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

repeat(x$1:java.util.function.BooleanSupplier):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

repeat(x$1:long):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

repeat(x$1:long, x$2:java.util.function.BooleanSupplier):reactor.core.publisher.Flux[reactor.core.publisher.Flux.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.Flux.T]

replay():reactor.core.publisher.ConnectableFlux[reactor.core.publisher.Flux.T]

replay(x$1:int):reactor.core.publisher.ConnectableFlux[reactor.core.publisher.Flux.T]

replay(x$1:int, x$2:java.time.Duration):reactor.core.publisher.ConnectableFlux[reactor.core.publisher.Flux.T]

replay(x$1:int, x$2:java.time.Duration, x$3:reactor.core.scheduler.Scheduler):reactor.core.publisher.ConnectableFlux[reactor.core.publisher.Flux.T]

replay(x$1:java.time.Duration):reactor.core.publisher.ConnectableFlux[reactor.core.publisher.Flux.T]

replay(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.ConnectableFlux[reactor.core.publisher.Flux.T]

retry():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

retry(x$1:long):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

retryWhen(x$1:reactor.util.retry.Retry):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

sample(x$1:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

sample(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.U]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

sampleFirst(x$1:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

sampleFirst(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.U]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

sampleTimeout(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.U]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

sampleTimeout(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.U]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

scan(x$1:java.util.function.BiFunction[reactor.core.publisher.Flux.Treactor.core.publisher.Flux.Treactor.core.publisher.Flux.T]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

scan(x$1:reactor.core.publisher.Flux.A, x$2:java.util.function.BiFunction[Anyreactor.core.publisher.Flux.Areactor.core.publisher.Flux.A]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.A]

scanWith(x$1:java.util.function.Supplier[reactor.core.publisher.Flux.A], x$2:java.util.function.BiFunction[Anyreactor.core.publisher.Flux.Areactor.core.publisher.Flux.A]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.A]

share():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

shareNext():reactor.core.publisher.Mono[reactor.core.publisher.Flux.T]

single():reactor.core.publisher.Mono[reactor.core.publisher.Flux.T]

single(x$1:reactor.core.publisher.Flux.T):reactor.core.publisher.Mono[reactor.core.publisher.Flux.T]

singleOrEmpty():reactor.core.publisher.Mono[reactor.core.publisher.Flux.T]

skip(x$1:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

skip(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

skip(x$1:long):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

skipLast(x$1:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

skipUntil(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

skipUntilOther(x$1:org.reactivestreams.Publisher[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

skipWhile(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

sort():reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

sort(x$1:java.util.Comparator[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

startWith(x$1:Unknown Nothing):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

startWith(x$1:java.lang.Iterable[reactor.core.publisher.Flux.T]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

startWith(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

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.Flux[reactor.core.publisher.Flux.T]

subscribeOn(x$1:reactor.core.scheduler.Scheduler, x$2:boolean):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

subscribeWith(x$1:reactor.core.publisher.Flux.E):reactor.core.publisher.Flux.E

subscriberContext(x$1:java.util.function.Function[reactor.util.context.Contextreactor.util.context.Context]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

subscriberContext(x$1:reactor.util.context.Context):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

switchIfEmpty(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

switchMap(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

switchMap(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

switchOnFirst(x$1:java.util.function.BiFunction[org.reactivestreams.Publisher[reactor.core.publisher.Flux.V]reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]reactor.core.publisher.Signal[reactor.core.publisher.Flux.T]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

switchOnFirst(x$1:java.util.function.BiFunction[org.reactivestreams.Publisher[reactor.core.publisher.Flux.V]reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]reactor.core.publisher.Signal[reactor.core.publisher.Flux.T]], x$2:boolean):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

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.Flux[reactor.core.publisher.Flux.T]

take(x$1:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

take(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

take(x$1:long):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

take(x$1:long, x$2:boolean):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

takeLast(x$1:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

takeUntil(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

takeUntilOther(x$1:org.reactivestreams.Publisher[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

takeWhile(x$1:java.util.function.Predicate[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

then():reactor.core.publisher.Mono[java.lang.Void]

then(x$1:reactor.core.publisher.Mono[reactor.core.publisher.Flux.V]):reactor.core.publisher.Mono[reactor.core.publisher.Flux.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.Flux.V]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

timed():reactor.core.publisher.Flux[reactor.core.publisher.Timed[reactor.core.publisher.Flux.T]]

timed(x$1:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Timed[reactor.core.publisher.Flux.T]]

timeout(x$1:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

timeout(x$1:java.time.Duration, x$2:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

timeout(x$1:java.time.Duration, x$2:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T], x$3:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

timeout(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

timeout(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.U]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

timeout(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.U], x$2:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

timeout(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.U], x$2:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]], x$3:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]

timestamp():reactor.core.publisher.Flux[reactor.util.function.Tuple2[java.lang.Longreactor.core.publisher.Flux.T]]

timestamp(x$1:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.util.function.Tuple2[java.lang.Longreactor.core.publisher.Flux.T]]

toIterable():java.lang.Iterable[reactor.core.publisher.Flux.T]

toIterable(x$1:int):java.lang.Iterable[reactor.core.publisher.Flux.T]

toIterable(x$1:int, x$2:java.util.function.Supplier[java.util.Queue[reactor.core.publisher.Flux.T]]):java.lang.Iterable[reactor.core.publisher.Flux.T]

toStream():java.util.stream.Stream[reactor.core.publisher.Flux.T]

toStream(x$1:int):java.util.stream.Stream[reactor.core.publisher.Flux.T]

toString():java.lang.String

transform(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

transformDeferred(x$1:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

transformDeferredContextual(x$1:java.util.function.BiFunction[AnyAnyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

wait():Unit

wait(x$1:long):Unit

wait(x$1:long, x$2:int):Unit

window(x$1:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

window(x$1:int, x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

window(x$1:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

window(x$1:java.time.Duration, x$2:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

window(x$1:java.time.Duration, x$2:java.time.Duration, x$3:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

window(x$1:java.time.Duration, x$2:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

window(x$1:org.reactivestreams.Publisher[Any]):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowTimeout(x$1:int, x$2:java.time.Duration):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowTimeout(x$1:int, x$2:java.time.Duration, x$3:boolean):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowTimeout(x$1:int, x$2:java.time.Duration, x$3:reactor.core.scheduler.Scheduler):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowTimeout(x$1:int, x$2:java.time.Duration, x$3:reactor.core.scheduler.Scheduler, x$4:boolean):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowUntil(x$1:java.util.function.Predicate[reactor.core.publisher.Flux.T]):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowUntil(x$1:java.util.function.Predicate[reactor.core.publisher.Flux.T], x$2:boolean):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowUntil(x$1:java.util.function.Predicate[reactor.core.publisher.Flux.T], x$2:boolean, x$3:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowUntilChanged():reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowUntilChanged(x$1:java.util.function.Function[AnyAny]):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowUntilChanged(x$1:java.util.function.Function[Anyreactor.core.publisher.Flux.V], x$2:java.util.function.BiPredicate[AnyAny]):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowWhen(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.U], x$2:java.util.function.Function[Anyorg.reactivestreams.Publisher[reactor.core.publisher.Flux.V]]):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowWhile(x$1:java.util.function.Predicate[reactor.core.publisher.Flux.T]):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

windowWhile(x$1:java.util.function.Predicate[reactor.core.publisher.Flux.T], x$2:int):reactor.core.publisher.Flux[reactor.core.publisher.Flux[reactor.core.publisher.Flux.T]]

withLatestFrom(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.U], x$2:java.util.function.BiFunction[AnyAnyreactor.core.publisher.Flux.R]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.R]

zipWith(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T2]):reactor.core.publisher.Flux[reactor.util.function.Tuple2[reactor.core.publisher.Flux.Treactor.core.publisher.Flux.T2]]

zipWith(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T2], x$2:int):reactor.core.publisher.Flux[reactor.util.function.Tuple2[reactor.core.publisher.Flux.Treactor.core.publisher.Flux.T2]]

zipWith(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T2], x$2:int, x$3:java.util.function.BiFunction[AnyAnyreactor.core.publisher.Flux.V]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

zipWith(x$1:org.reactivestreams.Publisher[reactor.core.publisher.Flux.T2], x$2:java.util.function.BiFunction[AnyAnyreactor.core.publisher.Flux.V]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]

zipWithIterable(x$1:java.lang.Iterable[reactor.core.publisher.Flux.T2]):reactor.core.publisher.Flux[reactor.util.function.Tuple2[reactor.core.publisher.Flux.Treactor.core.publisher.Flux.T2]]

zipWithIterable(x$1:java.lang.Iterable[reactor.core.publisher.Flux.T2], x$2:java.util.function.BiFunction[AnyAnyreactor.core.publisher.Flux.V]):reactor.core.publisher.Flux[reactor.core.publisher.Flux.V]