scaladsl

Type Members

final class Balance[T] extends GraphStage[UniformFanOutShape[T, T]]

Fan-out the stream to several streams.
Fan-out the stream to several streams. Each upstream element is emitted to the first available downstream consumer. It will not shut down until the subscriptions for at least two downstream subscribers have been established.
A Balance has one in port and 2 or more out ports.
Emits when any of the outputs stops backpressuring; emits the element to the first available output
Backpressures when all of the outputs backpressure
Completes when upstream completes
Cancels when If eagerCancel is enabled: when any downstream cancels; otherwise: when all downstreams cancel
final class BidiFlow[-I1, +O1, -I2, +O2, +Mat] extends Graph[BidiShape[I1, O1, I2, O2], Mat]
final class Broadcast[T] extends GraphStage[UniformFanOutShape[T, T]]

Fan-out the stream to several streams emitting each incoming upstream element to all downstream consumers.
Fan-out the stream to several streams emitting each incoming upstream element to all downstream consumers. It will not shut down until the subscriptions for at least two downstream subscribers have been established.
Emits when all of the outputs stops backpressuring and there is an input element available
Backpressures when any of the outputs backpressure
Completes when upstream completes
Cancels when If eagerCancel is enabled: when any downstream cancels; otherwise: when all downstreams cancel
final class Concat[T] extends GraphStage[UniformFanInShape[T, T]]

Takes multiple streams and outputs one stream formed from the input streams by first emitting all of the elements from the first stream and then emitting all of the elements from the second stream, etc.
Takes multiple streams and outputs one stream formed from the input streams by first emitting all of the elements from the first stream and then emitting all of the elements from the second stream, etc.
A Concat has one first port, one second port and one out port.
Emits when the current stream has an element available; if the current input completes, it tries the next one
Backpressures when downstream backpressures
Completes when all upstreams complete
Cancels when downstream cancels
final class Flow[-In, +Out, +Mat] extends FlowOpsMat[Out, Mat] with Graph[FlowShape[In, Out], Mat]

A Flow is a set of stream processing steps that has one open input and one open output.
trait FlowOps[+Out, +Mat] extends AnyRef

Scala API: Operations offered by Sources and Flows with a free output side: the DSL flows left-to-right only.
Scala API: Operations offered by Sources and Flows with a free output side: the DSL flows left-to-right only.
INTERNAL API: this trait will be changed in binary-incompatible ways for classes that are derived from it! Do not implement this interface outside the Akka code base!
Binary compatibility is only maintained for callers of this trait’s interface.

Annotations
@DoNotInherit()
trait FlowOpsMat[+Out, +Mat] extends FlowOps[Out, Mat]

INTERNAL API: this trait will be changed in binary-incompatible ways for classes that are derived from it! Do not implement this interface outside the Akka code base!
INTERNAL API: this trait will be changed in binary-incompatible ways for classes that are derived from it! Do not implement this interface outside the Akka code base!
Binary compatibility is only maintained for callers of this trait’s interface.
final class FlowWithContext[-CtxIn, -In, +CtxOut, +Out, +Mat] extends GraphDelegate[FlowShape[(In, CtxIn), (Out, CtxOut)], Mat] with FlowWithContextOps[CtxOut, Out, Mat]

A flow that provides operations which automatically propagate the context of an element.
A flow that provides operations which automatically propagate the context of an element. Only a subset of common operations from FlowOps is supported. As an escape hatch you can use FlowWithContextOps.via to manually provide the context propagation for otherwise unsupported operations.
An "empty" flow can be created by calling FlowWithContext[Ctx, T].
API MAY CHANGE

Annotations
@ApiMayChange()
trait FlowWithContextOps[+Ctx, +Out, +Mat] extends AnyRef

Shared stream operations for FlowWithContext and SourceWithContext that automatically propagate a context element with each data element.
Shared stream operations for FlowWithContext and SourceWithContext that automatically propagate a context element with each data element.
API MAY CHANGE

Annotations
@ApiMayChange()
trait GraphApply extends AnyRef
final class Interleave[T] extends GraphStage[UniformFanInShape[T, T]]

Interleave represents deterministic merge which takes N elements per input stream, in-order of inputs, emits them downstream and then cycles/"wraps-around" the inputs.
Interleave represents deterministic merge which takes N elements per input stream, in-order of inputs, emits them downstream and then cycles/"wraps-around" the inputs.
Emits when element is available from current input (depending on phase)
Backpressures when downstream backpressures
Completes when all upstreams complete (eagerClose=false) or one upstream completes (eagerClose=true)
Cancels when downstream cancels
final class Merge[T] extends GraphStage[UniformFanInShape[T, T]]

Merge several streams, taking elements as they arrive from input streams (picking randomly when several have elements ready).
Merge several streams, taking elements as they arrive from input streams (picking randomly when several have elements ready).
Emits when one of the inputs has an element available
Backpressures when downstream backpressures
Completes when all upstreams complete (eagerComplete=false) or one upstream completes (eagerComplete=true), default value is false
Cancels when downstream cancels
final class MergeLatest[T, M] extends GraphStage[UniformFanInShape[T, M]]
final class MergePreferred[T] extends GraphStage[MergePreferredShape[T]]

Merge several streams, taking elements as they arrive from input streams (picking from preferred when several have elements ready).
Merge several streams, taking elements as they arrive from input streams (picking from preferred when several have elements ready).
A MergePreferred has one out port, one preferred input port and 1 or more secondary in ports.
Emits when one of the inputs has an element available, preferring a specified input if multiple have elements available
Backpressures when downstream backpressures
Completes when all upstreams complete (eagerComplete=false) or one upstream completes (eagerComplete=true), default value is false
Cancels when downstream cancels
final class MergePrioritized[T] extends GraphStage[UniformFanInShape[T, T]]

Merge several streams, taking elements as they arrive from input streams (picking from prioritized once when several have elements ready).
Merge several streams, taking elements as they arrive from input streams (picking from prioritized once when several have elements ready).
A MergePrioritized has one out port, one or more input port with their priorities.
Emits when one of the inputs has an element available, preferring a input based on its priority if multiple have elements available
Backpressures when downstream backpressures
Completes when all upstreams complete (eagerComplete=false) or one upstream completes (eagerComplete=true), default value is false
Cancels when downstream cancels
final class MergeSorted[T] extends GraphStage[FanInShape2[T, T, T]]

Merge two pre-sorted streams such that the resulting stream is sorted.
Merge two pre-sorted streams such that the resulting stream is sorted.
Emits when both inputs have an element available
Backpressures when downstream backpressures
Completes when all upstreams complete
Cancels when downstream cancels
final class Partition[T] extends GraphStage[UniformFanOutShape[T, T]]

Fan-out the stream to several streams.
Fan-out the stream to several streams. emitting an incoming upstream element to one downstream consumer according to the partitioner function applied to the element
Emits when emits when an element is available from the input and the chosen output has demand
Backpressures when the currently chosen output back-pressures
Completes when upstream completes and no output is pending
Cancels when all downstreams have cancelled (eagerCancel=false) or one downstream cancels (eagerCancel=true)
final case class RunnableGraph[+Mat](traversalBuilder: TraversalBuilder) extends Graph[ClosedShape, Mat] with Product with Serializable

Flow with attached input and output, can be executed.
trait ScalaSessionAPI extends AnyRef

Allows access to an SSLSession with Scala types
final class Sink[-In, +Mat] extends Graph[SinkShape[In], Mat]

A Sink is a set of stream processing steps that has one open input.
A Sink is a set of stream processing steps that has one open input. Can be used as a Subscriber
trait SinkQueue[T] extends AnyRef

Trait allows to have the queue as a sink for some stream.
Trait allows to have the queue as a sink for some stream. "SinkQueue" pulls data from stream with backpressure mechanism.
trait SinkQueueWithCancel[T] extends SinkQueue[T]

This trait adds cancel support to SinkQueue.
implicit final class SinkToCompletionStage[In, T] extends AnyVal
final class Source[+Out, +Mat] extends FlowOpsMat[Out, Mat] with Graph[SourceShape[Out], Mat]

A Source is a set of stream processing steps that has one open output.
A Source is a set of stream processing steps that has one open output. It can comprise any number of internal sources and transformations that are wired together, or it can be an “atomic” source, e.g. from a collection or a file. Materialization turns a Source into a Reactive Streams Publisher (at least conceptually).
trait SourceQueue[T] extends AnyRef

This trait allows to have the queue as a data source for some stream.
trait SourceQueueWithComplete[T] extends SourceQueue[T]

This trait adds completion support to SourceQueue.
implicit final class SourceToCompletionStage[Out, T] extends AnyVal
final class SourceWithContext[+Ctx, +Out, +Mat] extends GraphDelegate[SourceShape[(Out, Ctx)], Mat] with FlowWithContextOps[Ctx, Out, Mat]

A source that provides operations which automatically propagate the context of an element.
A source that provides operations which automatically propagate the context of an element. Only a subset of common operations from FlowOps is supported. As an escape hatch you can use FlowWithContextOps.via to manually provide the context propagation for otherwise unsupported operations.
Can be created by calling Source.startContextPropagation()
API MAY CHANGE

Annotations
@ApiMayChange()
trait SubFlow[+Out, +Mat, +F[+_], C] extends FlowOps[Out, Mat]

A “stream of streams” sub-flow of data elements, e.g.
A “stream of streams” sub-flow of data elements, e.g. produced by groupBy. SubFlows cannot contribute to the super-flow’s materialized value since they are materialized later, during the runtime of the flow graph processing.
final class Tcp extends Extension
final class TcpIdleTimeoutException extends TimeoutException with NoStackTrace
final class Unzip[A, B] extends UnzipWith2[(A, B), A, B]

Takes a stream of pair elements and splits each pair to two output streams.
Takes a stream of pair elements and splits each pair to two output streams.
An Unzip has one in port and one left and one right output port.
Emits when all of the outputs stop backpressuring and there is an input element available
Backpressures when any of the outputs backpressure
Completes when upstream completes
Cancels when any downstream cancels
class UnzipWith10[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10] extends GraphStage[FanOutShape10[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]]

UnzipWith specialized for 10 outputs
class UnzipWith11[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11] extends GraphStage[FanOutShape11[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]]

UnzipWith specialized for 11 outputs
class UnzipWith12[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12] extends GraphStage[FanOutShape12[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]]

UnzipWith specialized for 12 outputs
class UnzipWith13[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13] extends GraphStage[FanOutShape13[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]]

UnzipWith specialized for 13 outputs
class UnzipWith14[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14] extends GraphStage[FanOutShape14[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]]

UnzipWith specialized for 14 outputs
class UnzipWith15[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15] extends GraphStage[FanOutShape15[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]]

UnzipWith specialized for 15 outputs
class UnzipWith16[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16] extends GraphStage[FanOutShape16[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]]

UnzipWith specialized for 16 outputs
class UnzipWith17[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17] extends GraphStage[FanOutShape17[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17]]

UnzipWith specialized for 17 outputs
class UnzipWith18[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18] extends GraphStage[FanOutShape18[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18]]

UnzipWith specialized for 18 outputs
class UnzipWith19[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19] extends GraphStage[FanOutShape19[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19]]

UnzipWith specialized for 19 outputs
class UnzipWith2[In, A1, A2] extends GraphStage[FanOutShape2[In, A1, A2]]

UnzipWith specialized for 2 outputs
class UnzipWith20[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20] extends GraphStage[FanOutShape20[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20]]

UnzipWith specialized for 20 outputs
class UnzipWith21[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21] extends GraphStage[FanOutShape21[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21]]

UnzipWith specialized for 21 outputs
class UnzipWith22[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22] extends GraphStage[FanOutShape22[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22]]

UnzipWith specialized for 22 outputs
class UnzipWith3[In, A1, A2, A3] extends GraphStage[FanOutShape3[In, A1, A2, A3]]

UnzipWith specialized for 3 outputs
class UnzipWith4[In, A1, A2, A3, A4] extends GraphStage[FanOutShape4[In, A1, A2, A3, A4]]

UnzipWith specialized for 4 outputs
class UnzipWith5[In, A1, A2, A3, A4, A5] extends GraphStage[FanOutShape5[In, A1, A2, A3, A4, A5]]

UnzipWith specialized for 5 outputs
class UnzipWith6[In, A1, A2, A3, A4, A5, A6] extends GraphStage[FanOutShape6[In, A1, A2, A3, A4, A5, A6]]

UnzipWith specialized for 6 outputs
class UnzipWith7[In, A1, A2, A3, A4, A5, A6, A7] extends GraphStage[FanOutShape7[In, A1, A2, A3, A4, A5, A6, A7]]

UnzipWith specialized for 7 outputs
class UnzipWith8[In, A1, A2, A3, A4, A5, A6, A7, A8] extends GraphStage[FanOutShape8[In, A1, A2, A3, A4, A5, A6, A7, A8]]

UnzipWith specialized for 8 outputs
class UnzipWith9[In, A1, A2, A3, A4, A5, A6, A7, A8, A9] extends GraphStage[FanOutShape9[In, A1, A2, A3, A4, A5, A6, A7, A8, A9]]

UnzipWith specialized for 9 outputs
trait UnzipWithApply extends AnyRef
final class Zip[A, B] extends ZipWith2[A, B, (A, B)]

Combine the elements of 2 streams into a stream of tuples.
Combine the elements of 2 streams into a stream of tuples.
A Zip has a left and a right input port and one out port
Emits when all of the inputs has an element available
Backpressures when downstream backpressures
Completes when any upstream completes
Cancels when downstream cancels
final class ZipLatest[A, B] extends ZipLatestWith2[A, B, (A, B)]

Combine the elements of 2 streams into a stream of tuples, picking always the latest element of each.
Combine the elements of 2 streams into a stream of tuples, picking always the latest element of each.
A ZipLatest has a left and a right input port and one out port.
No element is emitted until at least one element from each Source becomes available.
Emits when all of the inputs have at least an element available, and then each time an element becomes * available on either of the inputs
Backpressures when downstream backpressures
Completes when any upstream completes
Cancels when downstream cancels
class ZipLatestWith10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, O] extends GraphStage[FanInShape10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, O]]

ZipLatestWith specialized for 10 inputs
class ZipLatestWith11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, O] extends GraphStage[FanInShape11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, O]]

ZipLatestWith specialized for 11 inputs
class ZipLatestWith12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, O] extends GraphStage[FanInShape12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, O]]

ZipLatestWith specialized for 12 inputs
class ZipLatestWith13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, O] extends GraphStage[FanInShape13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, O]]

ZipLatestWith specialized for 13 inputs
class ZipLatestWith14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, O] extends GraphStage[FanInShape14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, O]]

ZipLatestWith specialized for 14 inputs
class ZipLatestWith15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, O] extends GraphStage[FanInShape15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, O]]

ZipLatestWith specialized for 15 inputs
class ZipLatestWith16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, O] extends GraphStage[FanInShape16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, O]]

ZipLatestWith specialized for 16 inputs
class ZipLatestWith17[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, O] extends GraphStage[FanInShape17[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, O]]

ZipLatestWith specialized for 17 inputs
class ZipLatestWith18[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, O] extends GraphStage[FanInShape18[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, O]]

ZipLatestWith specialized for 18 inputs
class ZipLatestWith19[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, O] extends GraphStage[FanInShape19[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, O]]

ZipLatestWith specialized for 19 inputs
class ZipLatestWith2[A1, A2, O] extends GraphStage[FanInShape2[A1, A2, O]]

ZipLatestWith specialized for 2 inputs
class ZipLatestWith20[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, O] extends GraphStage[FanInShape20[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, O]]

ZipLatestWith specialized for 20 inputs
class ZipLatestWith21[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, O] extends GraphStage[FanInShape21[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, O]]

ZipLatestWith specialized for 21 inputs
class ZipLatestWith22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, O] extends GraphStage[FanInShape22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, O]]

ZipLatestWith specialized for 22 inputs
class ZipLatestWith3[A1, A2, A3, O] extends GraphStage[FanInShape3[A1, A2, A3, O]]

ZipLatestWith specialized for 3 inputs
class ZipLatestWith4[A1, A2, A3, A4, O] extends GraphStage[FanInShape4[A1, A2, A3, A4, O]]

ZipLatestWith specialized for 4 inputs
class ZipLatestWith5[A1, A2, A3, A4, A5, O] extends GraphStage[FanInShape5[A1, A2, A3, A4, A5, O]]

ZipLatestWith specialized for 5 inputs
class ZipLatestWith6[A1, A2, A3, A4, A5, A6, O] extends GraphStage[FanInShape6[A1, A2, A3, A4, A5, A6, O]]

ZipLatestWith specialized for 6 inputs
class ZipLatestWith7[A1, A2, A3, A4, A5, A6, A7, O] extends GraphStage[FanInShape7[A1, A2, A3, A4, A5, A6, A7, O]]

ZipLatestWith specialized for 7 inputs
class ZipLatestWith8[A1, A2, A3, A4, A5, A6, A7, A8, O] extends GraphStage[FanInShape8[A1, A2, A3, A4, A5, A6, A7, A8, O]]

ZipLatestWith specialized for 8 inputs
class ZipLatestWith9[A1, A2, A3, A4, A5, A6, A7, A8, A9, O] extends GraphStage[FanInShape9[A1, A2, A3, A4, A5, A6, A7, A8, A9, O]]

ZipLatestWith specialized for 9 inputs
trait ZipLatestWithApply extends AnyRef
final class ZipN[A] extends ZipWithN[A, Seq[A]]

Combine the elements of multiple streams into a stream of sequences.
Combine the elements of multiple streams into a stream of sequences.
A ZipN has a n input ports and one out port
Emits when all of the inputs has an element available
Backpressures when downstream backpressures
Completes when any upstream completes
Cancels when downstream cancels
class ZipWith10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, O] extends GraphStage[FanInShape10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, O]]

ZipWith specialized for 10 inputs
class ZipWith11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, O] extends GraphStage[FanInShape11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, O]]

ZipWith specialized for 11 inputs
class ZipWith12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, O] extends GraphStage[FanInShape12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, O]]

ZipWith specialized for 12 inputs
class ZipWith13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, O] extends GraphStage[FanInShape13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, O]]

ZipWith specialized for 13 inputs
class ZipWith14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, O] extends GraphStage[FanInShape14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, O]]

ZipWith specialized for 14 inputs
class ZipWith15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, O] extends GraphStage[FanInShape15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, O]]

ZipWith specialized for 15 inputs
class ZipWith16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, O] extends GraphStage[FanInShape16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, O]]

ZipWith specialized for 16 inputs
class ZipWith17[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, O] extends GraphStage[FanInShape17[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, O]]

ZipWith specialized for 17 inputs
class ZipWith18[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, O] extends GraphStage[FanInShape18[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, O]]

ZipWith specialized for 18 inputs
class ZipWith19[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, O] extends GraphStage[FanInShape19[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, O]]

ZipWith specialized for 19 inputs
class ZipWith2[A1, A2, O] extends GraphStage[FanInShape2[A1, A2, O]]

ZipWith specialized for 2 inputs
class ZipWith20[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, O] extends GraphStage[FanInShape20[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, O]]

ZipWith specialized for 20 inputs
class ZipWith21[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, O] extends GraphStage[FanInShape21[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, O]]

ZipWith specialized for 21 inputs
class ZipWith22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, O] extends GraphStage[FanInShape22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, O]]

ZipWith specialized for 22 inputs
class ZipWith3[A1, A2, A3, O] extends GraphStage[FanInShape3[A1, A2, A3, O]]

ZipWith specialized for 3 inputs
class ZipWith4[A1, A2, A3, A4, O] extends GraphStage[FanInShape4[A1, A2, A3, A4, O]]

ZipWith specialized for 4 inputs
class ZipWith5[A1, A2, A3, A4, A5, O] extends GraphStage[FanInShape5[A1, A2, A3, A4, A5, O]]

ZipWith specialized for 5 inputs
class ZipWith6[A1, A2, A3, A4, A5, A6, O] extends GraphStage[FanInShape6[A1, A2, A3, A4, A5, A6, O]]

ZipWith specialized for 6 inputs
class ZipWith7[A1, A2, A3, A4, A5, A6, A7, O] extends GraphStage[FanInShape7[A1, A2, A3, A4, A5, A6, A7, O]]

ZipWith specialized for 7 inputs
class ZipWith8[A1, A2, A3, A4, A5, A6, A7, A8, O] extends GraphStage[FanInShape8[A1, A2, A3, A4, A5, A6, A7, A8, O]]

ZipWith specialized for 8 inputs
class ZipWith9[A1, A2, A3, A4, A5, A6, A7, A8, A9, O] extends GraphStage[FanInShape9[A1, A2, A3, A4, A5, A6, A7, A8, A9, O]]

ZipWith specialized for 9 inputs
trait ZipWithApply extends AnyRef
class ZipWithN[A, O] extends GraphStage[UniformFanInShape[A, O]]

Combine the elements of multiple streams into a stream of sequences using a combiner function.
Combine the elements of multiple streams into a stream of sequences using a combiner function.
A ZipWithN has a n input ports and one out port
Emits when all of the inputs has an element available
Backpressures when downstream backpressures
Completes when any upstream completes
Cancels when downstream cancels

Value Members

object Balance
object BidiFlow
object Broadcast
object BroadcastHub

A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers.
A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers. It consists of two parts, a Sink and a Source. The Sink broadcasts elements from a producer to the actually live consumers it has. Once the producer has been materialized, the Sink it feeds into returns a materialized value which is the corresponding Source. This Source can be materialized an arbitrary number of times, where each of the new materializations will receive their elements from the original Sink.
object Compression
object Concat
object CoupledTerminationFlow

Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow them them.
Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow them them. Similar to Flow.fromSinkAndSource however that API does not connect the completion signals of the wrapped operators.
object FileIO

Factories to create sinks and sources from files
object Flow
object FlowWithContext

API MAY CHANGE
API MAY CHANGE

Annotations
@ApiMayChange()
object Framing
object GraphDSL extends GraphApply
object Interleave
object JsonFraming

Provides JSON framing operators that can separate valid JSON objects from incoming ByteString objects.
object Keep

Convenience functions for often-encountered purposes like keeping only the left (first) or only the right (second) of two input values.
object Merge
object MergeHub

A MergeHub is a special streaming hub that is able to collect streamed elements from a dynamic set of producers.
A MergeHub is a special streaming hub that is able to collect streamed elements from a dynamic set of producers. It consists of two parts, a Source and a Sink. The Source streams the element to a consumer from its merged inputs. Once the consumer has been materialized, the Source returns a materialized value which is the corresponding Sink. This Sink can then be materialized arbitrary many times, where each of the new materializations will feed its consumed elements to the original Source.
object MergeLatest

MergeLatest joins elements from N input streams into stream of lists of size N.
MergeLatest joins elements from N input streams into stream of lists of size N. i-th element in list is the latest emitted element from i-th input stream. MergeLatest emits list for each element emitted from some input stream, but only after each stream emitted at least one element
Emits when element is available from some input and each input emits at least one element from stream start
Completes when all upstreams complete (eagerClose=false) or one upstream completes (eagerClose=true)
Cancels when downstream cancels
object MergePreferred
object MergePrioritized
object OrElse
object Partition
object PartitionHub

A PartitionHub is a special streaming hub that is able to route streamed elements to a dynamic set of consumers.
A PartitionHub is a special streaming hub that is able to route streamed elements to a dynamic set of consumers. It consists of two parts, a Sink and a Source. The Sink e elements from a producer to the actually live consumers it has. The selection of consumer is done with a function. Each element can be routed to only one consumer. Once the producer has been materialized, the Sink it feeds into returns a materialized value which is the corresponding Source. This Source can be materialized an arbitrary number of times, where each of the new materializations will receive their elements from the original Sink.
object RestartFlow

A RestartFlow wraps a Flow that gets restarted when it completes or fails.
A RestartFlow wraps a Flow that gets restarted when it completes or fails.
They are useful for graphs that need to run for longer than the Flow can necessarily guarantee it will, for example, for Flow streams that depend on a remote server that may crash or become partitioned. The RestartFlow ensures that the graph can continue running while the Flow restarts.
object RestartSink

A RestartSink wraps a Sink that gets restarted when it completes or fails.
A RestartSink wraps a Sink that gets restarted when it completes or fails.
They are useful for graphs that need to run for longer than the Sink can necessarily guarantee it will, for example, for Sink streams that depend on a remote server that may crash or become partitioned. The RestartSink ensures that the graph can continue running while the Sink restarts.
object RestartSource

A RestartSource wraps a Source that gets restarted when it completes or fails.
A RestartSource wraps a Source that gets restarted when it completes or fails.
They are useful for graphs that need to run for longer than the Source can necessarily guarantee it will, for example, for Source streams that depend on a remote server that may crash or become partitioned. The RestartSource ensures that the graph can continue running while the Source restarts.
object RestartWithBackoffFlow
object RunnableGraph extends Serializable
object ScalaSessionAPI
object Sink
object Source
object StreamConverters

Converters for interacting with the blocking java.io streams APIs and Java 8 Streams
object StreamRefs

API MAY CHANGE: The functionality of stream refs is working, however it is expected that the materialized value will eventually be able to remove the Future wrapping the stream references.
API MAY CHANGE: The functionality of stream refs is working, however it is expected that the materialized value will eventually be able to remove the Future wrapping the stream references. For this reason the API is now marked as API may change. See ticket https://github.com/akka/akka/issues/24372 for more details.
Factories for creating stream refs.

Annotations
@ApiMayChange()
object TLS

Stream cipher support based upon JSSE.
Stream cipher support based upon JSSE.
The underlying SSLEngine has four ports: plaintext input/output and ciphertext input/output. These are modeled as a akka.stream.BidiShape element for use in stream topologies, where the plaintext ports are on the left hand side of the shape and the ciphertext ports on the right hand side.
Configuring JSSE is a rather complex topic, please refer to the JDK platform documentation or the excellent user guide that is part of the Play Framework documentation. The philosophy of this integration into Akka Streams is to expose all knobs and dials to client code and therefore not limit the configuration possibilities. In particular the client code will have to provide the SSLContext from which the SSLEngine is then created. Handshake parameters are set using NegotiateNewSession messages, the settings for the initial handshake need to be provided up front using the same class; please refer to the method documentation below.
IMPORTANT NOTE
The TLS specification does not permit half-closing of the user data session that it transports—to be precise a half-close will always promptly lead to a full close. This means that canceling the plaintext output or completing the plaintext input of the SslTls operator will lead to full termination of the secure connection without regard to whether bytes are remaining to be sent or received, respectively. Especially for a client the common idiom of attaching a finite Source to the plaintext input and transforming the plaintext response bytes coming out will not work out of the box due to early termination of the connection. For this reason there is a parameter that determines whether the SslTls operator shall ignore completion and/or cancellation events, and the default is to ignore completion (in view of the client–server scenario). In order to terminate the connection the client will then need to cancel the plaintext output as soon as all expected bytes have been received. When ignoring both types of events the operator will shut down once both events have been received. See also TLSClosing.
object TLSPlacebo

This object holds simple wrapping akka.stream.scaladsl.BidiFlow implementations that can be used instead of TLS when no encryption is desired.
This object holds simple wrapping akka.stream.scaladsl.BidiFlow implementations that can be used instead of TLS when no encryption is desired. The flows will just adapt the message protocol by wrapping into SessionBytes and unwrapping SendBytes.
object Tcp extends ExtensionId[Tcp] with ExtensionIdProvider
object Unzip

Takes a stream of pair elements and splits each pair to two output streams.
Takes a stream of pair elements and splits each pair to two output streams.
An Unzip has one in port and one left and one right output port.
Emits when all of the outputs stop backpressuring and there is an input element available
Backpressures when any of the outputs backpressure
Completes when upstream completes
Cancels when any downstream cancels
object UnzipWith extends UnzipWithApply

Transforms each element of input stream into multiple streams using a splitter function.
Transforms each element of input stream into multiple streams using a splitter function.
Emits when all of the outputs stop backpressuring and there is an input element available
Backpressures when any of the outputs backpressure
Completes when upstream completes
Cancels when any downstream cancels
object UnzipWithApply
object WireTap
object Zip
object ZipLatest
object ZipLatestWith extends ZipLatestWithApply

Combine the elements of multiple streams into a stream of combined elements using a combiner function, picking always the latest of the elements of each source.
Combine the elements of multiple streams into a stream of combined elements using a combiner function, picking always the latest of the elements of each source.
No element is emitted until at least one element from each Source becomes available. Whenever a new element appears, the zipping function is invoked with a tuple containing the new element and the other last seen elements.
Emits when all of the inputs have at least an element available, and then each time an element becomes available on either of the inputs
Backpressures when downstream backpressures
Completes when any of the upstreams completes
Cancels when downstream cancels
object ZipN
object ZipWith extends ZipWithApply

Combine the elements of multiple streams into a stream of combined elements using a combiner function.
Combine the elements of multiple streams into a stream of combined elements using a combiner function.
Emits when all of the inputs has an element available
Backpressures when downstream backpressures
Completes when any upstream completes
Cancels when downstream cancels
object ZipWithN

package scaladsl

Type Members

final class Balance[T] extends GraphStage[UniformFanOutShape[T, T]]

final class BidiFlow[-I1, +O1, -I2, +O2, +Mat] extends Graph[BidiShape[I1, O1, I2, O2], Mat]

final class Broadcast[T] extends GraphStage[UniformFanOutShape[T, T]]

final class Concat[T] extends GraphStage[UniformFanInShape[T, T]]

final class Flow[-In, +Out, +Mat] extends FlowOpsMat[Out, Mat] with Graph[FlowShape[In, Out], Mat]

trait FlowOps[+Out, +Mat] extends AnyRef

trait FlowOpsMat[+Out, +Mat] extends FlowOps[Out, Mat]

final class FlowWithContext[-CtxIn, -In, +CtxOut, +Out, +Mat] extends GraphDelegate[FlowShape[(In, CtxIn), (Out, CtxOut)], Mat] with FlowWithContextOps[CtxOut, Out, Mat]

trait FlowWithContextOps[+Ctx, +Out, +Mat] extends AnyRef

trait GraphApply extends AnyRef

final class Interleave[T] extends GraphStage[UniformFanInShape[T, T]]

final class Merge[T] extends GraphStage[UniformFanInShape[T, T]]

final class MergeLatest[T, M] extends GraphStage[UniformFanInShape[T, M]]

final class MergePreferred[T] extends GraphStage[MergePreferredShape[T]]

final class MergePrioritized[T] extends GraphStage[UniformFanInShape[T, T]]

final class MergeSorted[T] extends GraphStage[FanInShape2[T, T, T]]

final class Partition[T] extends GraphStage[UniformFanOutShape[T, T]]

final case class RunnableGraph[+Mat](traversalBuilder: TraversalBuilder) extends Graph[ClosedShape, Mat] with Product with Serializable

trait ScalaSessionAPI extends AnyRef

final class Sink[-In, +Mat] extends Graph[SinkShape[In], Mat]

trait SinkQueue[T] extends AnyRef

trait SinkQueueWithCancel[T] extends SinkQueue[T]

implicit final class SinkToCompletionStage[In, T] extends AnyVal

final class Source[+Out, +Mat] extends FlowOpsMat[Out, Mat] with Graph[SourceShape[Out], Mat]

trait SourceQueue[T] extends AnyRef

trait SourceQueueWithComplete[T] extends SourceQueue[T]

implicit final class SourceToCompletionStage[Out, T] extends AnyVal

final class SourceWithContext[+Ctx, +Out, +Mat] extends GraphDelegate[SourceShape[(Out, Ctx)], Mat] with FlowWithContextOps[Ctx, Out, Mat]

trait SubFlow[+Out, +Mat, +F[+_], C] extends FlowOps[Out, Mat]

final class Tcp extends Extension

final class TcpIdleTimeoutException extends TimeoutException with NoStackTrace

final class Unzip[A, B] extends UnzipWith2[(A, B), A, B]

class UnzipWith10[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10] extends GraphStage[FanOutShape10[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]]

class UnzipWith11[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11] extends GraphStage[FanOutShape11[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]]

class UnzipWith12[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12] extends GraphStage[FanOutShape12[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]]

class UnzipWith13[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13] extends GraphStage[FanOutShape13[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]]

class UnzipWith14[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14] extends GraphStage[FanOutShape14[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]]

class UnzipWith15[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15] extends GraphStage[FanOutShape15[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]]

class UnzipWith16[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16] extends GraphStage[FanOutShape16[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]]

class UnzipWith17[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17] extends GraphStage[FanOutShape17[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17]]

class UnzipWith18[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18] extends GraphStage[FanOutShape18[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18]]

class UnzipWith19[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19] extends GraphStage[FanOutShape19[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19]]

class UnzipWith2[In, A1, A2] extends GraphStage[FanOutShape2[In, A1, A2]]

class UnzipWith20[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20] extends GraphStage[FanOutShape20[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20]]

class UnzipWith21[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21] extends GraphStage[FanOutShape21[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21]]

class UnzipWith22[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22] extends GraphStage[FanOutShape22[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22]]

class UnzipWith3[In, A1, A2, A3] extends GraphStage[FanOutShape3[In, A1, A2, A3]]

class UnzipWith4[In, A1, A2, A3, A4] extends GraphStage[FanOutShape4[In, A1, A2, A3, A4]]

class UnzipWith5[In, A1, A2, A3, A4, A5] extends GraphStage[FanOutShape5[In, A1, A2, A3, A4, A5]]

class UnzipWith6[In, A1, A2, A3, A4, A5, A6] extends GraphStage[FanOutShape6[In, A1, A2, A3, A4, A5, A6]]

class UnzipWith7[In, A1, A2, A3, A4, A5, A6, A7] extends GraphStage[FanOutShape7[In, A1, A2, A3, A4, A5, A6, A7]]

class UnzipWith8[In, A1, A2, A3, A4, A5, A6, A7, A8] extends GraphStage[FanOutShape8[In, A1, A2, A3, A4, A5, A6, A7, A8]]

class UnzipWith9[In, A1, A2, A3, A4, A5, A6, A7, A8, A9] extends GraphStage[FanOutShape9[In, A1, A2, A3, A4, A5, A6, A7, A8, A9]]

trait UnzipWithApply extends AnyRef

final class Zip[A, B] extends ZipWith2[A, B, (A, B)]

final class ZipLatest[A, B] extends ZipLatestWith2[A, B, (A, B)]

class ZipLatestWith10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, O] extends GraphStage[FanInShape10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, O]]

class ZipLatestWith11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, O] extends GraphStage[FanInShape11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, O]]

class ZipLatestWith12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, O] extends GraphStage[FanInShape12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, O]]

class ZipLatestWith13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, O] extends GraphStage[FanInShape13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, O]]

class ZipLatestWith14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, O] extends GraphStage[FanInShape14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, O]]

class ZipLatestWith15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, O] extends GraphStage[FanInShape15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, O]]

class ZipLatestWith16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, O] extends GraphStage[FanInShape16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, O]]

class ZipLatestWith17[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, O] extends GraphStage[FanInShape17[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, O]]

class ZipLatestWith18[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, O] extends GraphStage[FanInShape18[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, O]]

class ZipLatestWith19[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, O] extends GraphStage[FanInShape19[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, O]]

class ZipLatestWith2[A1, A2, O] extends GraphStage[FanInShape2[A1, A2, O]]

class ZipLatestWith20[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, O] extends GraphStage[FanInShape20[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, O]]

class ZipLatestWith21[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, O] extends GraphStage[FanInShape21[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, O]]

class ZipLatestWith22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, O] extends GraphStage[FanInShape22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, O]]

class ZipLatestWith3[A1, A2, A3, O] extends GraphStage[FanInShape3[A1, A2, A3, O]]

class ZipLatestWith4[A1, A2, A3, A4, O] extends GraphStage[FanInShape4[A1, A2, A3, A4, O]]

class ZipLatestWith5[A1, A2, A3, A4, A5, O] extends GraphStage[FanInShape5[A1, A2, A3, A4, A5, O]]

class ZipLatestWith6[A1, A2, A3, A4, A5, A6, O] extends GraphStage[FanInShape6[A1, A2, A3, A4, A5, A6, O]]

class ZipLatestWith7[A1, A2, A3, A4, A5, A6, A7, O] extends GraphStage[FanInShape7[A1, A2, A3, A4, A5, A6, A7, O]]

class ZipLatestWith8[A1, A2, A3, A4, A5, A6, A7, A8, O] extends GraphStage[FanInShape8[A1, A2, A3, A4, A5, A6, A7, A8, O]]

class ZipLatestWith9[A1, A2, A3, A4, A5, A6, A7, A8, A9, O] extends GraphStage[FanInShape9[A1, A2, A3, A4, A5, A6, A7, A8, A9, O]]