All Classes (Flink : Runtime 2.0.0 API)

All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
Class	Description
AbstractAccessExecutionGraphHandler<R extends ResponseBody,M extends JobMessageParameters>	`AbstractAccessExecutionGraphHandler` handles requests that require accessing the job's `AccessExecutionGraph`.
AbstractAggregatedMetricsHeaders<P extends AbstractAggregatedMetricsParameters<?>>	Based `MessageHeaders` class for aggregating metrics.
AbstractAggregatedMetricsParameters<M extends MessageQueryParameter<?>>	Base `MessageParameters` class for aggregating metrics.
AbstractAggregatingMetricsHandler<P extends AbstractAggregatedMetricsParameters<?>>	Abstract request handler for querying aggregated metrics.
AbstractAggregatingState<K,N,IN,ACC,OUT>	The default implementation of `AggregatingState`, which delegates all async requests to `StateRequestHandler`.
AbstractAsynchronousOperationHandlers<K extends OperationKey,R extends Serializable>	HTTP handlers for asynchronous operations.
AbstractAsyncStateStreamOperator<OUT>	This operator is an abstract class that give the `AbstractStreamOperator` the ability to perform `AsyncStateProcessing`.
AbstractAsyncStateStreamOperatorV2<OUT>	This operator is an abstract class that give the `AbstractStreamOperatorV2` the ability to perform `AsyncStateProcessing`.
AbstractAsyncStateUdfStreamOperator<OUT,F extends org.apache.flink.api.common.functions.Function>	This is used as the base class for operators that have a user-defined function.
AbstractBlobCache	Abstract base class for permanent and transient BLOB files.
AbstractBroadcastStateTransformation<IN1,IN2,OUT>	Base class for Broadcast State transformations.
AbstractBuffersUsageGauge	Abstract gauge implementation for calculating the buffer usage percent.
AbstractCachedBuildSideJoinDriver<IT1,IT2,OT>
AbstractChannelReaderInputView	A `DataInputView` that is backed by a `FileIOChannel`, making it effectively a data input stream.
AbstractChannelStateHandle<Info>	Abstract channel state handle.
AbstractChannelStateHandle.StateContentMetaInfo	Describes the underlying content.
AbstractChannelWriterOutputView	A `DataOutputView` that is backed by a `FileIOChannel`, making it effectively a data output stream.
AbstractCheckpointHandler<R extends ResponseBody,M extends CheckpointMessageParameters>	Base class for checkpoint related REST handler.
AbstractCheckpointMessage	The base class of all checkpoint messages.
AbstractCheckpointStats	Base class for checkpoint statistics.
AbstractCheckpointStatsHandler<R extends ResponseBody,M extends JobMessageParameters>	Abstract class for checkpoint handlers that will cache the `CheckpointStatsSnapshot` object.
AbstractCollectResultBuffer<T>	A buffer which encapsulates the logic of dealing with the response from the `CollectSinkFunction`.
AbstractCompleteCheckpointStore	The abstract class of `CompletedCheckpointStore`, which holds the `SharedStateRegistry` and provides the registration of shared state.
AbstractCompositeBuffer	An implementation of `Buffer` which contains multiple partial buffers for network data communication.
AbstractDispatcherLeaderProcess	A base `DispatcherLeaderProcess`.
AbstractDispatcherLeaderProcess.DispatcherGatewayService	An accessor of the `DispatcherGateway`.
AbstractDispatcherLeaderProcess.DispatcherGatewayServiceFactory	Factory for `AbstractDispatcherLeaderProcess.DispatcherGatewayService`.
AbstractDispatcherLeaderProcess.State	The state of the `DispatcherLeaderProcess`.
AbstractEvent	This type of event can be used to exchange notification messages between different `TaskExecutor` objects at runtime using the communication channels.
AbstractExecutionGraphHandler<R extends ResponseBody,M extends JobMessageParameters>	Base class for all `ExecutionGraphInfo` based REST handlers.
AbstractFileIOChannel
AbstractFileStateBackend	Deprecated. State backends should no longer implement `CheckpointStorage` functionality.
AbstractFsCheckpointStorageAccess	An implementation of durable checkpoint storage to file systems.
AbstractHandler<T extends RestfulGateway,R extends RequestBody,M extends MessageParameters>	Super class for netty-based handlers that work with `RequestBody`.
AbstractHaServices	Abstract high availability services based on distributed system(e.g.
AbstractHashTableProber<PT,BT>
AbstractHeapPriorityQueue<T extends HeapPriorityQueueElement>	Abstract base class for heap (object array) based implementations of priority queues, with support for fast deletes via `HeapPriorityQueueElement`.
AbstractHeapPriorityQueueElement	Abstract base class for `HeapPriorityQueueElement`.
AbstractHeapState<K,N,SV>	Base class for partitioned `State` implementations that are backed by a regular heap hash map.
AbstractIncrementalStateHandle	Abstract superclass for all `IncrementalKeyedStateHandle`.
AbstractInternalWatermarkDeclaration<T>	The `AbstractInternalWatermarkDeclaration` class implements the `WatermarkDeclaration` interface and provides some internal-oriented methods, such as getting/setting the `align` flag and creating the `WatermarkCombiner`.
AbstractInvokable	A base implementation of `TaskInvokable`, `CheckpointableTask`, and `CoordinatedTask` with most methods throwing `UnsupportedOperationException` or doing nothing.
AbstractIterativeTask<S extends org.apache.flink.api.common.functions.Function,OT>	The abstract base class for all tasks able to participate in an iteration.
AbstractJobManagerFileHandler<M extends MessageParameters>	Base class for serving files from the JobManager.
AbstractJobVertexHandler<R extends ResponseBody,M extends JobVertexMessageParameters>	Base class for request handlers whose response depends on a specific job vertex (defined via the "`JobVertexIdPathParameter.KEY`" parameter) in a specific job, defined via (defined via the "`JobIDPathParameter.KEY`" parameter).
AbstractKeyedState<K,N,V>	The `AbstractKeyedState` is the root of the abstract state implementation hierarchy, similar to the `State` being the root of the public API state hierarchy.
AbstractKeyedStateBackend<K>	Base implementation of KeyedStateBackend.
AbstractKeyedStateBackend.PartitionStateFactory
AbstractKeyedStateBackendBuilder<K>	An abstract base implementation of the `StateBackendBuilder` interface.
AbstractListState<K,N,V>	A default implementation of `ListState` which delegates all async requests to `StateRequestHandler`.
AbstractManagedMemoryStateBackend	Abstract base class for state backends that use managed memory.
AbstractMapState<K,N,UK,V>	A default implementation of `MapState` which delegates all async requests to `StateRequestHandler`.
AbstractMergeInnerJoinIterator<T1,T2,O>	An implementation of the `JoinTaskIterator` that realizes the joining through a sort-merge join strategy.
AbstractMergeIterator<T1,T2,O>
AbstractMergeOuterJoinIterator<T1,T2,O>	An implementation of the `JoinTaskIterator` that realizes the outer join through a sort-merge join strategy.
AbstractMetricGroup<A extends AbstractMetricGroup<?>>	Abstract `MetricGroup` that contains key functionality for adding metrics and groups.
AbstractMetricGroup.ChildType	Enum for indicating which child group should be created.
AbstractMetricsHandler<M extends MessageParameters>	Request handler that returns for a given task a list of all available metrics or the values for a set of metrics.
AbstractMetricsHeaders<M extends MessageParameters>	`MessageHeaders` for `AbstractMetricsHandler`.
AbstractMultipleInputTransformation<OUT>	Base class for transformations representing the application of a `MultipleInputStreamOperator` to input `Transformations`.
AbstractMutableHashTable<T>
AbstractNonHaServices	Abstract base class for non high-availability services.
AbstractOuterJoinDriver<IT1,IT2,OT>	The abstract outer join driver implements the logic of an outer join operator at runtime.
AbstractPagedInputView	The base class for all input views that are backed by multiple memory pages.
AbstractPagedOutputView	The base class for all output views that are backed by multiple memory pages.
AbstractPartitionTracker<K,M>	Base partition tracker implementation, providing underlying data-structures for storing partitions, their associated keys and meta-information.
AbstractReader	A basic reader implementation, which wraps an input gate and handles events.
AbstractReducingState<K,N,V>	A default implementation of `ReducingState` which delegates all async requests to `StateRequestHandler`.
AbstractResourceManagerDriver<WorkerType extends ResourceIDRetrievable>	Abstract common base class for implementations of `ResourceManagerDriver`.
AbstractResourceManagerHandler<T extends RestfulGateway,R extends RequestBody,P extends ResponseBody,M extends MessageParameters>	Base class for REST handlers which need access to the `ResourceManager`.
AbstractRestHandler<T extends RestfulGateway,R extends RequestBody,P extends ResponseBody,M extends MessageParameters>	Super class for netty-based handlers that work with `RequestBody`s and `ResponseBody`s.
AbstractServiceConnectionManager<S>	Base class for service connection managers, taking care of the connection handling.
AbstractSlotPoolServiceFactory	Abstract SlotPoolServiceFactory.
AbstractStateBackend	An abstract base implementation of the `StateBackend` interface.
AbstractStateIterator<T>	A `StateIterator` implementation to facilitate async data load of iterator.
AbstractStreamOperator<OUT>	Base class for all stream operators.
AbstractStreamOperatorFactory<OUT>	Base class for all stream operator factories.
AbstractStreamOperatorV2<OUT>	New base class for all stream operators, intended to eventually replace `AbstractStreamOperator`.
AbstractStreamTaskNetworkInput<T,R extends RecordDeserializer<DeserializationDelegate<StreamElement>>>	Base class for network-based StreamTaskInput where each channel has a designated `RecordDeserializer` for spanning records.
AbstractSubtaskAttemptHandler<R extends ResponseBody,M extends SubtaskAttemptMessageParameters>	Base class for request handlers whose response depends on a specific attempt (defined via the "`SubtaskAttemptPathParameter.KEY`" of a specific subtask (defined via the "`SubtaskIndexPathParameter.KEY`" in a specific job vertex, (defined via the "`JobVertexIdPathParameter.KEY`" parameter) in a specific job, defined via (defined via the "`JobIDPathParameter.KEY`" parameter).
AbstractSubtaskHandler<R extends ResponseBody,M extends SubtaskMessageParameters>	Base class for request handlers whose response depends on a specific subtask (defined via the "`SubtaskIndexPathParameter.KEY`" in a specific job vertex, (defined via the "`JobVertexIdPathParameter.KEY`" parameter) in a specific job, defined via (defined via the "`JobIDPathParameter.KEY`" parameter).
AbstractTaskManagerFileHandler<M extends TaskManagerMessageParameters>	Base class for serving files from the `TaskExecutor`.
AbstractThreadsafeJobResultStore	An abstract class for threadsafe implementations of the `JobResultStore`.
AbstractTtlDecorator<T>	Base class for TTL logic wrappers.
AbstractTwoInputStreamTask<IN1,IN2,OUT>	Abstract class for executing a `TwoInputStreamOperator`.
AbstractTwoInputTransformationTranslator<IN1,IN2,OUT,OP extends org.apache.flink.api.dag.Transformation<OUT>>	A base class with functionality used during translating `transformations` with two inputs.
AbstractUdfStreamOperator<OUT,F extends org.apache.flink.api.common.functions.Function>	This is used as the base class for operators that have a user-defined function.
AbstractUserClassPathJobGraphRetriever	Abstract class for the JobGraphRetriever which supports getting user classpaths.
AbstractValueState<K,N,V>	A default implementation of `ValueState` which delegates all async requests to `AsyncExecutionController`.
AccessExecution	Common interface for the runtime `Execution` and `ArchivedExecution`.
AccessExecutionGraph	Common interface for the runtime `DefaultExecutionGraph` and `ArchivedExecutionGraph`.
AccessExecutionJobVertex	Common interface for the runtime `ExecutionJobVertex` and `ArchivedExecutionJobVertex`.
AccessExecutionVertex	Common interface for the runtime `ExecutionVertex` and `ArchivedExecutionVertex`.
AccumulatorRegistry	Main accumulator registry which encapsulates user-defined accumulators.
AccumulatorReport	A report about the current values of all accumulators of the TaskExecutor for a given job.
AccumulatorsIncludeSerializedValueQueryParameter	Query parameter for job's accumulator handler `JobAccumulatorsHandler`.
AccumulatorSnapshot	This class encapsulates a map of accumulators for a single task.
Acknowledge	A generic acknowledgement message.
AcknowledgeCheckpoint	This message is sent from the `TaskExecutor` to the `JobMaster` to signal that the checkpoint of an individual task is completed.
AcknowledgeCheckpointEvent	An `OperatorEvent` sent from a subtask to its `OperatorCoordinator` to signal that the checkpoint of an individual task is completed.
AcrossCheckpointFileMergingSnapshotManager	A `FileMergingSnapshotManager` that merging files across checkpoints.
ActiveResourceManager<WorkerType extends ResourceIDRetrievable>	An active implementation of `ResourceManager`.
ActiveResourceManagerFactory<WorkerType extends ResourceIDRetrievable>	Factory class for creating `ActiveResourceManager` with various implementations of `ResourceManagerDriver`.
AdaptiveBatchScheduler	This scheduler decides the parallelism of JobVertex according to the data volume it consumes.
AdaptiveBatchSchedulerFactory	Factory for `AdaptiveBatchScheduler`.
AdaptiveExecutionHandler	The `AdaptiveExecutionHandler` interface defines the operations for handling the adaptive execution of batch jobs.
AdaptiveExecutionHandlerFactory	A factory class for creating instances of `AdaptiveExecutionHandler`.
AdaptiveExecutionPlanSchedulingContext	The `AdaptiveExecutionPlanSchedulingContext` class implements the `ExecutionPlanSchedulingContext` interface to provide a dynamic scheduling context that adapts execution plans based on runtime conditions.
AdaptiveGraphGenerator	Defines the mechanism for dynamically adapting the graph topology of a Flink job at runtime.
AdaptiveGraphManager	Default implementation for `AdaptiveGraphGenerator`.
AdaptiveScheduler	A `SchedulerNG` implementation that uses the declarative resource management and automatically adapts the parallelism in case not enough resource could be acquired to run at the configured parallelism, as described in FLIP-160.
AdaptiveScheduler.Settings	Consolidated settings for the adaptive scheduler.
AdaptiveSchedulerFactory	Factory for the adaptive scheduler.
AddSplitEvent<SplitT>	A source event that adds splits to a source reader.
AggregateApplyAllWindowFunction<W extends Window,T,ACC,V,R>	A `AllWindowFunction` that composes an `AggregateFunction` and `AllWindowFunction`.
AggregateApplyWindowFunction<K,W extends Window,T,ACC,V,R>	A `WindowFunction` that composes an `AggregateFunction` and `WindowFunction`.
AggregatedBlockingInputInfo	Helper class that aggregates input information with the same typeNumber so that they can be processed as a single unit.
AggregatedJobMetricsHeaders	Headers for aggregating job metrics.
AggregatedJobMetricsParameters	Parameters for aggregating job metrics.
AggregatedMetric	Response type for aggregated metrics.
AggregatedMetricsResponseBody	Response type for a collection of aggregated metrics.
AggregatedMetricsResponseBody.Deserializer	JSON deserializer for `AggregatedMetricsResponseBody`.
AggregatedMetricsResponseBody.Serializer	JSON serializer for `AggregatedMetricsResponseBody`.
AggregatedSubtaskMetricsHeaders	Headers for aggregating subtask metrics.
AggregatedSubtaskMetricsParameters	Parameters for aggregating subtask metrics.
AggregatedTaskDetailsInfo	Aggregated info of a set of tasks.
AggregatedTaskManagerMetricsHeaders	Headers for aggregating task manager metrics.
AggregateTaskManagerMetricsParameters	Parameters for aggregating task manager metrics.
AggregatingJobsMetricsHandler	Request handler that returns, aggregated across jobs, a list of all available metrics or the values for a set of metrics.
AggregatingStateAdaptor<K,N,IN,ACC,OUT>	An adaptor that transforms `InternalAggregatingState` into `InternalAggregatingState`.
AggregatingSubtasksMetricsHandler	Request handler that returns, aggregated across subtasks, a list of all available metrics or the values for a set of metrics.
AggregatingTaskManagersMetricsHandler	Request handler that returns, aggregated across task managers, a list of all available metrics or the values for a set of metrics.
AggregationFunction<T>	Holder class for aggregation types that can be used on a windowed stream or keyed stream.
AggregationFunction.AggregationType	Aggregation types that can be used on a windowed stream or keyed stream.
AirBlockCompressor	Flink compressor that wraps `Compressor`.
AirBlockDecompressor	Flink decompressor that wraps `Decompressor`.
AirCompressorFactory	`BlockCompressionFactory` to create wrapped `Compressor` and `Decompressor`.
Alignable	An interface used to represent the special `WatermarkDeclaration`s can create aligned `Watermark`s, which need to be aligned when the operator receives them from input channels.
AlignableBoolWatermarkDeclaration	An alignable `BoolWatermarkDeclaration`.
AlignableLongWatermarkDeclaration	An alignable `LongWatermarkDeclaration`.
AlignedWatermarkCombiner	A `WatermarkCombiner` is design to align `Watermark`s.
AllFinishedInputConsumableDecider	`AllFinishedInputConsumableDecider` is a special `InputConsumableDecider`.
AllFinishedInputConsumableDecider.Factory	Factory for `AllFinishedInputConsumableDecider`.
AllGroupCombineDriver<IN,OUT>	Non-chained driver for the partial group reduce operator that acts like a combiner with a custom output type OUT.
AllGroupReduceDriver<IT,OT>	GroupReduceDriver task which is executed by a Task Manager.
AllocatedSlotActions	Interface for components which have to perform actions on allocated slots.
AllocatedSlotInfo	Information about an allocated slot which is owned by a JobMaster.
AllocatedSlotPool	The slot pool is responsible for maintaining a set of `AllocatedSlots`.
AllocatedSlotPool.AllocatedSlotsAndReservationStatus	A collection of `AllocatedSlots` and their reservation status.
AllocatedSlotPool.FreeSlotInfo	Information about a free slot.
AllocatedSlotReport	The report of currently allocated slots from a given TaskExecutor by a JobMaster.
AllocationID	Unique identifier for a physical slot allocated by a JobManager via the ResourceManager from a TaskManager.
AllReduceDriver<T>	Reduce task which is executed by a Task Manager.
AllTieredShuffleMasterSnapshots	This is a collection of all `TieredShuffleMasterSnapshot`s from every tier in one snapshot round.
AllToAllBlockingResultInfo	Information of All-To-All result.
AllToAllVertexInputInfoComputer	Helper class that computes VertexInputInfo for all to all like inputs.
AllWindowedStream<T,W extends Window>	A `AllWindowedStream` represents a data stream where the stream of elements is split into windows based on a `WindowAssigner`.
AllWindowFunction<IN,OUT,W extends Window>	Base interface for functions that are evaluated over non-keyed windows.
AllWorkersDoneEvent	Event sent by the `IterationSynchronizationSinkTask` to each `IterationHead` signaling to start a new superstep.
ApplicationStatus	The status of an application.
ArbitraryWorkerResourceSpecFactory	Implementation of `WorkerResourceSpecFactory` that creates arbitrary `WorkerResourceSpec`.
ArchivedExecution	`ArchivedExecution` is a readonly representation of `Execution`.
ArchivedExecutionGraph	An archived execution graph represents a serializable form of an `ExecutionGraph`.
ArchivedExecutionJobVertex
ArchivedExecutionVertex	`ArchivedExecutionVertex` is a readonly representation of `ExecutionVertex`.
ArchivedJson	A simple container for a handler's JSON response and the REST URLs for which the response would've been returned.
ArrayListSerializer<T>
ArrayListSerializerSnapshot<T>	Snapshot class for the `ArrayListSerializer`.
AssignRangeIndex<IN>	This mapPartition function require a DataSet with RangeBoundaries as broadcast input, it generate Tuple2 which includes range index and record itself as output.
AsyncContinuousEventTimeTrigger<W extends Window>	A `AsyncTrigger` that continuously fires based on a given time interval.
AsyncCountTrigger<W extends Window>	A `AsyncTrigger` that fires once the count of elements in a pane reaches the given count.
AsyncEventTimeTrigger	A `AsyncTrigger` that fires once the watermark passes the end of the window to which a pane belongs.
AsyncEvictingWindowOperator<K,IN,OUT,W extends Window>	A `AsyncWindowOperator` that also allows an `Evictor` to be used.
AsyncExceptionHandler	An interface marking a task as capable of handling exceptions thrown by different threads, other than the one executing the task itself.
AsyncExecutionController<K>	The Async Execution Controller (AEC) receives processing requests from operators, and put them into execution according to some strategies.
AsyncExecutionController.SwitchContextListener<K>	A listener listens the key context switch.
AsynchronousBlockReader	A reader that reads data in blocks from a file channel.
AsynchronousBlockWriter
AsynchronousBlockWriterWithCallback	An asynchronous implementation of the `BlockChannelWriterWithCallback` that queues I/O requests and calls a callback once they have been handled.
AsynchronousBufferFileReader
AsynchronousBufferFileSegmentReader
AsynchronousBufferFileWriter
AsynchronousBulkBlockReader
AsynchronousException	An exception for wrapping exceptions that are thrown by an operator in threads other than the main compute thread of that operator.
AsynchronousFileIOChannel<T,R extends org.apache.flink.runtime.io.disk.iomanager.IORequest>	A base class for readers and writers that accept read or write requests for whole blocks.
AsynchronousJobOperationKey	A pair of `JobID` and `TriggerId` used as a key to a hash based collection.
AsynchronouslyCreatedResource<T>	Interface for REST resources that are created asynchronously.
AsynchronousOperationInfo	Basic information object for asynchronous operations.
AsynchronousOperationResult<V>	Result of an asynchronous operation.
AsynchronousOperationStatusMessageHeaders<V,M extends MessageParameters>	Message headers for the status polling of an asynchronous operation.
AsynchronousOperationTriggerMessageHeaders<R extends RequestBody,M extends MessageParameters>	Message headers for the triggering of an asynchronous operation.
AsyncIntervalJoinOperator<K,T1,T2,OUT>	An `operator` to execute time-bounded stream inner joins.
AsyncKeyedProcessOperator<K,IN,OUT>	A `StreamOperator` for executing `KeyedProcessFunction` with async state processing.
AsyncKeyedStateBackend<K>	An async keyed state backend provides methods supporting to access keyed state asynchronously and in batch.
AsyncKeyedStateBackendAdaptor<K>	A adaptor that transforms `KeyedStateBackend` into `AsyncKeyedStateBackend`.
AsyncProcessingTimeTrigger	A `Trigger` that fires once the current system time passes the end of the window to which a pane belongs.
AsyncPurgingTrigger<T,W extends Window>	A trigger that can turn any `AsyncTrigger` into a purging `Trigger`.
AsyncSnapshotCallable<T>	Base class that outlines the strategy for asynchronous snapshots.
AsyncStateException	An exception for wrapping exceptions that are thrown by `StateFuture` callback framework.
AsyncStateProcessing	This class defines the basic interfaces to process a state in operator/input layer.
AsyncStateProcessingOperator	A more detailed interface based on `AsyncStateProcessing`, which gives the essential methods for an operator to perform async state processing.
AsyncStreamFlatMap<IN,OUT>	A `AbstractAsyncStateStreamOperator` for executing `FlatMapFunctions`.
AsyncTrigger<T,W extends Window>	A `Trigger` determines when a pane of a window should be evaluated to emit the results for that part of the window.
AsyncTrigger.OnMergeContext	Extension of `AsyncTrigger.TriggerContext` that is given to `AsyncTrigger.onMerge(Window, OnMergeContext)`.
AsyncTrigger.TriggerContext	A context object that is given to `AsyncTrigger` methods to allow them to register timer callbacks and deal with state.
AsyncWindowOperator<K,IN,ACC,OUT,W extends Window>	An operator that implements the logic for windowing based on a `WindowAssigner` and `AsyncTrigger`.
AvailabilityNotifier	`AvailabilityNotifier` is used to notify that the data from the specific partition and subpartition in tiered storage is available.
AvailabilityProvider	Interface defining couple of essential methods for listening on data availability using `CompletableFuture`.
AvailabilityProvider.AvailabilityHelper	A availability implementation for providing the helpful functions of resetting the available/unavailable states.
BackendBuildingException	Exceptions which indicate that a state backend building has failed.
BackendRestorerProcedure<T extends Closeable & org.apache.flink.util.Disposable,S extends StateObject>	This class implements the logic that creates (and potentially restores) a state backend.
BackendWritableBroadcastState<K,V>	An interface with methods related to the interplay between the `Broadcast State` and the `OperatorStateBackend`.
BarrierAlignmentUtil	Utility for barrier alignment.
BarrierAlignmentUtil.Cancellable	A handle to a delayed action which can be cancelled.
BarrierAlignmentUtil.DelayableTimer	It can register a task to be executed some time later.
BaseBroadcastProcessFunction	The base class containing the functionality available to all broadcast process function.
BaseTopology<VID extends VertexID,RID extends ResultID,V extends Vertex<VID,RID,V,R>,R extends Result<VID,RID,V,R>>	Base topology for all logical and execution topologies.
BashJavaUtils	Utility class for using java utilities in bash scripts.
BashJavaUtils.Command	Commands that BashJavaUtils supports.
BatchCoBroadcastWithKeyedOperator<KS,IN1,IN2,OUT>	A `TwoInputStreamOperator` for executing `KeyedBroadcastProcessFunctions` in `RuntimeExecutionMode.BATCH` execution mode.
BatchCoBroadcastWithNonKeyedOperator<IN1,IN2,OUT>	A `TwoInputStreamOperator` for executing `BroadcastProcessFunctions` in `RuntimeExecutionMode.BATCH` execution mode.
BatchExecutionCheckpointStorage	A simple `CheckpointStorage` which is used in a BATCH style execution.
BatchExecutionInternalTimeService<K,N>	An implementation of a `InternalTimerService` that manages timers with a single active key at a time.
BatchExecutionInternalTimeServiceManager<K>	An implementation of a `InternalTimeServiceManager` that manages timers with a single active key at a time.
BatchExecutionInternalTimeServiceWithAsyncState<K,N>	An implementation of a `InternalTimerService` that manages timers with a single active key at a time.
BatchExecutionKeyedStateBackend<K>	A `CheckpointableKeyedStateBackend` which keeps values for a single key at a time.
BatchExecutionOptionsInternal	Internal configuration options for the batch job execution.
BatchExecutionStateBackend	A simple `StateBackend` which is used in a BATCH style execution.
BatchExecutionUtils	A utility class for applying sorting inputs.
BatchGroupedReduceOperator<IN,KEY>	A `StreamOperator` for executing a `ReduceFunction` on a `KeyedStream` in a `RuntimeExecutionMode.BATCH` mode.
BatchJobRecoveryContext	Context for batch job recovery.
BatchJobRecoveryHandler	Interface for handling batch job recovery.
BatchShuffleReadBufferPool	A fixed-size `MemorySegment` pool used by batch shuffle for shuffle data read (currently only used by sort-merge blocking shuffle).
BatchTask<S extends org.apache.flink.api.common.functions.Function,OT>	The base class for all batch tasks.
BisectionSearchUtils	Utility class for bisection search.
BitSet
BlobCacheService	The BLOB cache provides access to BLOB services for permanent and transient BLOBs.
BlobCacheSizeTracker	BlobCacheSizeTracker uses `LinkedHashMap` to maintain the LRU order for the files in the cache.
BlobClient	The BLOB client can communicate with the BLOB server and either upload (PUT), download (GET), or delete (DELETE) BLOBs.
BlobKey	A BLOB key uniquely identifies a BLOB.
BlobLibraryCacheManager	Provides facilities to download a set of libraries (typically JAR files) for a job from a `PermanentBlobService` and create a class loader with references to them.
BlobLibraryCacheManager.ClassLoaderFactory
BlobServer	This class implements the BLOB server.
BlobServerProtocol	Defines constants for the protocol between the BLOB `server` and the `caches`.
BlobService	A simple store and retrieve binary large objects (BLOBs).
BlobStore	A blob store.
BlobStoreService	Service interface for the BlobStore which allows to close and clean up its data.
BlobUtils	Utility class to work with blob data.
BlobView	View on blobs stored in a `BlobStore`.
BlobWriter	BlobWriter is used to upload data to the BLOB store.
BlockChannelReader<T>	A reader that reads data in blocks from a file channel.
BlockChannelWriter<T>	A writer that writes data in blocks to a file channel.
BlockChannelWriterWithCallback<T>
BlockCompressionFactory	Each compression codec has a implementation of `BlockCompressionFactory` to create compressors and decompressors.
BlockCompressor	A compressor which compresses a whole byte array each time.
BlockDecompressor	A decompressor which decompresses a block each time.
BlockedNode	This class represents a blocked node record.
BlockedNodeRetriever	This class helps to retrieve the blocked nodes.
BlockedTaskManagerChecker	This checker helps to query whether a given task manager is blocked.
BlockingBackChannel	A concurrent datastructure that establishes a backchannel buffer between an iteration head and an iteration tail.
BlockingBackChannelBroker	Singleton class for the threadsafe handover of `BlockingBackChannel`s from iteration heads to iteration tails.
BlockingInputInfo	Helper class that provides read-only information of input for `VertexParallelismAndInputInfosDecider`.
BlockingPhysicalFilePool	A Blocking `PhysicalFilePool` which may block when polling physical files.
BlockingQueueBroker	`Broker` for the `BlockingQueue` used in `StreamIterationHead` and `StreamIterationTail` for implementing feedback streams.
BlockingResultInfo	The blocking result info, which will be used to calculate the vertex parallelism and input infos.
BlocklistContext	This class is responsible for blocking and unblocking resources.
BlocklistDeclarativeSlotPool	A `DeclarativeSlotPool` implementation that supports blocklist.
BlocklistDeclarativeSlotPoolFactory	Factory for `BlocklistDeclarativeSlotPool`.
BlocklistHandler	This class is responsible for managing all `BlockedNode`s and performing them on resources.
BlocklistHandler.Factory	Factory to instantiate `BlocklistHandler`.
BlocklistListener	A listener that want to be notified when blocklist changes.
BlocklistOperations	Operations to perform on the blocklist.
BlocklistTracker	A tracker for blocklist.
BlocklistUtils	Utility class for blocklist.
BlockResettableMutableObjectIterator<T>	Implementation of an iterator that fetches a block of data into main memory and offers resettable access to the data in that block.
BloomFilter	BloomFilter is a probabilistic data structure for set membership check.
BooleanArrayList	Minimal implementation of an array-backed list of booleans
BoolWatermarkCombiner	A `WatermarkCombiner` for unaligned `BoolWatermark`s.
BootstrapTools	Tools for starting JobManager and TaskManager processes.
BoundedBlockingResultPartition	A output data result of an individual task (one partition of an intermediate result), produced and communicated in a batch manner: The result must be produced completely before it can be consumed.
BoundedBlockingSubpartitionDirectTransferReader	The reader (read view) of a BoundedBlockingSubpartition based on `FileRegion`.
BoundedBlockingSubpartitionType	The type of the BoundedBlockingSubpartition.
BoundedFIFOQueue<T>	`BoundedFIFOQueue` collects elements up to given amount.
BoundedInputStream	Wrapper around a FSDataInputStream to limit the maximum read offset.
BoundedMultiInput	Interface for multi-input operators that need to be notified about the logical/semantical end of input.
BoundedOneInput	Interface for one-input operators that need to be notified about the logical/semantical end of input.
BroadcastConnectedStream<IN1,IN2>	A BroadcastConnectedStream represents the result of connecting a keyed or non-keyed stream, with a `BroadcastStream` with `broadcast state(s)`.
BroadcastPartitioner<T>	Partitioner that selects all the output channels.
BroadcastProcessFunction<IN1,IN2,OUT>	A function to be applied to a `BroadcastConnectedStream` that connects `BroadcastStream`, i.e.
BroadcastRecordWriter<T extends org.apache.flink.core.io.IOReadableWritable>	A special record-oriented runtime result writer only for broadcast mode.
BroadcastStateTransformation<IN1,IN2,OUT>	A non-keyed `AbstractBroadcastStateTransformation`.
BroadcastStateTransformationTranslator<IN1,IN2,OUT>	A `TransformationTranslator` for the `BroadcastStateTransformation`.
BroadcastStream<T>	A `BroadcastStream` is a stream with `broadcast state(s)`.
BroadcastVariableKey	An identifier for a `BroadcastVariableMaterialization` based on the task's `JobVertexID`, broadcast variable name and iteration superstep.
BroadcastVariableManager	The BroadcastVariableManager is used to manage the materialization of broadcast variables.
BroadcastVariableMaterialization<T,C>	This class represents a single materialization of a broadcast variable and maintains a reference count for it.
Broker<V>	A concurrent data structure that allows the hand-over of an object between a pair of threads.
Buffer	Wrapper for pooled `MemorySegment` instances with reference counting.
Buffer.DataType	Used to identify the type of data contained in the `Buffer` so that we can get the information without deserializing the serialized data.
BufferAccumulator	Accumulates received records into buffers.
BufferAvailabilityListener	Listener interface implemented by consumers of `ResultSubpartitionView` that want to be notified of availability of further buffers.
BufferBuilder	Not thread safe class for filling in the content of the `MemorySegment`.
BufferCompressionException	A `BufferCompressionException` is thrown when the target data cannot be compressed, such as insufficient target buffer space for compression, etc.
BufferCompressor	Compressor for `Buffer`.
BufferConsumer	Not thread safe class for producing `Buffer`.
BufferConsumerWithPartialRecordLength	BufferConsumer with partial record length if a record is spanning over buffers
BufferDebloatConfiguration	Configuration for `BufferDebloater`.
BufferDebloater	Class for automatic calculation of the buffer size based on the current throughput and configuration.
BufferDecompressionException	A `BufferDecompressionException` is thrown when the target data cannot be decompressed, such as data corruption, insufficient target buffer space for decompression, etc.
BufferDecompressor	Decompressor for compressed `Buffer`.
BufferFileChannelReader	Helper class to read `Buffer`s from files into objects.
BufferFileReader
BufferFileSegmentReader
BufferFileWriter
BufferHeader	Header fields of a `Buffer`.
BufferListener	Interface of the availability of buffers.
BufferManager	The general buffer manager used by `InputChannel` to request/recycle exclusive or floating buffers.
BufferOrEvent	Either type for `Buffer` or `AbstractEvent` instances tagged with the channel index, from which they were received.
BufferPool	A dynamically sized buffer pool.
BufferPoolFactory	A factory for buffer pools.
BufferProvider	A buffer provider to request buffers from in a synchronous or asynchronous fashion.
BufferReaderWriterUtil	Putting and getting of a sequence of buffers to/from a FileChannel or a ByteBuffer.
BufferRecycler	Interface for recycling `MemorySegment`s.
BufferRecycler.DummyBufferRecycler	The buffer recycler does nothing for recycled segment.
BufferSizeEMA	Implementation of 'Exponential moving average' algorithm.
BufferWithSubpartition	Buffer and the corresponding subpartition index.
BufferWritingResultPartition	A `ResultPartition` which writes buffers directly to `ResultSubpartition`s.
BuildFirstCachedJoinDriver<IT1,IT2,OT>
BuildSecondCachedJoinDriver<IT1,IT2,OT>
BulkBlockChannelReader
ByteBufUtils	Utility routines to process `ByteBuf`.
ByteStreamStateHandle	A state handle that contains stream state in a byte array.
CachedDataStream<T>	`CachedDataStream` represents a `DataStream` whose intermediate result will be cached at the first time when it is computed.
CachedShuffleDescriptors	`ShuffleDescriptor`s cache for a `ConsumedPartitionGroup`.
CacheTransformation<T>	When in batch mode, the `CacheTransformation` represents the intermediate result of the upper stream should be cached when it is computed at the first time.
CacheTransformationTranslator<OUT,T extends CacheTransformation<OUT>>	Translator for `CacheTransformationTranslator`.
CacheTransformationTranslator.IdentityStreamOperator<T>	The `CacheTransformationTranslator.IdentityStreamOperator` acts as a dummy source to consume cached intermediate dataset.
CacheTransformationTranslator.NoOpStreamOperator<T>	The `CacheTransformationTranslator.NoOpStreamOperator` acts as a dummy sink so that the upstream can produce the intermediate dataset to be cached.
CallbackRunnerWrapper	A `StateFutureImpl.CallbackRunner` that gives info of `CallbackRunnerWrapper.isHasMail()` to the AEC and notifies new mail if needed.
CancelCheckpointMarker	The CancelCheckpointMarker travels through the data streams, similar to the `CheckpointBarrier`, but signals that a certain checkpoint should be canceled.
CancelTaskException	Thrown to trigger a canceling of the executing task.
ChainedAllReduceDriver<IT>
ChainedDriver<IT,OT>	The interface to be implemented by drivers that do not run in an own task context, but are chained to other tasks.
ChainedFlatMapDriver<IT,OT>
ChainedMapDriver<IT,OT>
ChainedOperatorHashInfo	Helper class to help maintain the hash info of an operator chain.
ChainedReduceCombineDriver<T>	Chained version of ReduceCombineDriver.
ChainedSourceInfo	Helper class to help maintain the chained source info of an operator chain.
ChainedStateHandle<T extends StateObject>	Handle to state handles for the operators in an operator chain.
ChainingStrategy	Defines the chaining scheme for the operator.
ChangelogStateBackendHandle	A handle to ChangelogStateBackend state.
ChangelogStateBackendHandle.ChangelogStateBackendHandleImpl
ChangelogStateBackendLocalHandle	State handle for local copies of `ChangelogStateHandleStreamImpl`.
ChangelogStateHandle	A handle to saved `state changes`.
ChangelogStateHandleStreamImpl	`ChangelogStateHandle` implementation based on `StreamStateHandle`.
ChangelogTaskLocalStateStore	Changelog's implementation of a `TaskLocalStateStore`.
ChannelReaderInputView	A `DataInputView` that is backed by a `BlockChannelReader`, making it effectively a data input stream.
ChannelReaderInputViewIterator<E>	A simple iterator over the input read though an I/O channel.
ChannelSelector<T extends org.apache.flink.core.io.IOReadableWritable>	The `ChannelSelector` determines to which logical channels a record should be written to.
ChannelSelectorRecordWriter<T extends org.apache.flink.core.io.IOReadableWritable>	A regular record-oriented runtime result writer.
ChannelStateHolder	Implemented by entities that hold any kind of channel state and need a reference to the `ChannelStateWriter`.
ChannelStatePendingResult	The pending result of channel state for a specific checkpoint-subtask.
ChannelStatePersister	Helper class for persisting channel state via `ChannelStateWriter`.
ChannelStateWriter	Writes channel state during checkpoint/savepoint.
ChannelStateWriter.ChannelStateWriteResult	Channel state write result.
ChannelStateWriter.NoOpChannelStateWriter	No-op implementation of `ChannelStateWriter`.
ChannelStateWriteRequestExecutorFactory	The factory of `ChannelStateWriteRequestExecutor`.
ChannelStateWriterImpl	`ChannelStateWriter` implemented using `CheckpointStateOutputStreams`.
ChannelWriterOutputView	A `DataOutputView` that is backed by a `BlockChannelWriter`, making it effectively a data output stream.
Checkpoint	A checkpoint, pending or completed.
Checkpoint.DiscardObject	Extra interface for discarding the checkpoint.
CheckpointableInput	Input, with just basic methods for blocking and resuming consumption.
CheckpointableKeyedStateBackend<K>	Interface that combines both, the `KeyedStateBackend` interface, which encapsulates methods responsible for keyed state management and the `Snapshotable` which tells the system how to snapshot the underlying state.
CheckpointableTask	A task that participates in checkpointing.
CheckpointBarrier	Checkpoint barriers are used to align checkpoints throughout the streaming topology.
CheckpointBarrierHandler	The `CheckpointBarrierHandler` reacts to checkpoint barrier arriving from the input channels.
CheckpointBarrierTracker	The `CheckpointBarrierTracker` keeps track of what checkpoint barriers have been received from which input channels.
CheckpointBoundKeyedStateHandle	`KeyedStateHandle` that is bound to a specific checkpoint.
CheckpointCommittableManager<CommT>	A `CheckpointCommittableManager` collects committables for one checkpoint across potentially multiple upstream subtasks.
CheckpointConfig	Configuration that captures all checkpointing related settings.
CheckpointConfigHandler	Handler which serves the checkpoint configuration.
CheckpointConfigHeaders	Message headers for the `CheckpointConfigHandler`.
CheckpointConfigInfo	Response class of the `CheckpointConfigHandler`.
CheckpointConfigInfo.ExternalizedCheckpointInfo	Contains information about the externalized checkpoint configuration.
CheckpointConfigInfo.ProcessingMode	Processing mode.
CheckpointConfigInfo.ProcessingModeDeserializer	Processing mode deserializer.
CheckpointConfigInfo.ProcessingModeSerializer	JSON deserializer for `CheckpointConfigInfo.ProcessingMode`.
CheckpointCoordinator	The checkpoint coordinator coordinates the distributed snapshots of operators and state.
CheckpointCoordinatorConfiguration	Configuration settings for the `CheckpointCoordinator`.
CheckpointCoordinatorConfiguration.CheckpointCoordinatorConfigurationBuilder	`CheckpointCoordinatorConfiguration` builder.
CheckpointCoordinatorDeActivator	This actor listens to changes in the JobStatus and activates or deactivates the periodic checkpoint scheduler.
CheckpointCoordinatorGateway	RPC Gateway interface for messages to the CheckpointCoordinator.
CheckpointedCollectResultBuffer<T>	A buffer which encapsulates the logic of dealing with the response from the `CollectSinkFunction`.
CheckpointedFunction	This is the core interface for stateful transformation functions, meaning functions that maintain state across individual stream records.
CheckpointedInputGate	The `CheckpointedInputGate` uses `CheckpointBarrierHandler` to handle incoming `CheckpointBarrier` from the `InputGate`.
CheckpointedResultPartition	Interface for partitions that are checkpointed, meaning they store data as part of unaligned checkpoints.
CheckpointedStateScope	The scope for a chunk of checkpointed state.
CheckpointException	Base class for checkpoint related exceptions.
CheckpointFailureManager	The checkpoint failure manager which centralized manage checkpoint failure processing logic.
CheckpointFailureManager.FailJobCallback	A callback interface about how to fail a job.
CheckpointFailureReason	Various reasons why a checkpoint was failure.
CheckpointHandlers	HTTP handlers for asynchronous triggering of checkpoints.
CheckpointHandlers.CheckpointStatusHandler	HTTP handler to query for the status of the checkpoint.
CheckpointHandlers.CheckpointTriggerHandler	Handler for the checkpoint trigger operation.
CheckpointIDCounter	A checkpoint ID counter.
CheckpointIdPathParameter	Path parameter for the checkpoint id of type `Long`.
CheckpointInfo	Represents information about a triggered checkpoint.
CheckpointingMode	Deprecated. This class has been moved to `CheckpointingMode`.
CheckpointingStatistics	Response of the `CheckpointingStatisticsHandler`.
CheckpointingStatistics.Counts	Checkpoint counts.
CheckpointingStatistics.LatestCheckpoints	Statistics about the latest checkpoints.
CheckpointingStatistics.RestoredCheckpointStatistics	Statistics for a restored checkpoint.
CheckpointingStatistics.Summary	Checkpoint summary.
CheckpointingStatisticsHandler	Handler which serves the checkpoint statistics.
CheckpointingStatisticsHeaders	Message headers for the `CheckpointingStatisticsHandler`.
CheckpointMessageParameters	Message parameters for checkpoint related messages.
CheckpointMetadata	The metadata of a snapshot (checkpoint or savepoint).
CheckpointMetaData	Encapsulates all the meta data for a checkpoint.
CheckpointMetadataOutputStream	An output stream for checkpoint metadata.
CheckpointMetrics	A collection of simple metrics, around the triggering of a checkpoint.
CheckpointMetricsBuilder	A builder for `CheckpointMetrics`.
CheckpointOptions	Options for performing the checkpoint.
CheckpointOptions.AlignmentType	How a checkpoint should be aligned.
CheckpointPlan	The plan of one checkpoint, indicating which tasks to trigger, waiting for acknowledge or commit for one specific checkpoint.
CheckpointPlanCalculator	Calculates the plan of the next checkpoint, including the tasks to trigger, wait or commit for each checkpoint.
CheckpointPlanCalculatorContext	Provides the context for `DefaultCheckpointPlanCalculator` to compute the plan of checkpoints.
CheckpointProperties	The configuration of a checkpoint.
CheckpointRecoveryFactory	A factory for per Job checkpoint recovery components.
CheckpointResourcesCleanupRunner	`CheckpointResourcesCleanupRunner` implements `JobManagerRunner` in a way, that only the checkpoint-related resources are instantiated.
CheckpointResourcesCleanupRunnerFactory	`CheckpointResourcesCleanupRunnerFactory` implements `CleanupRunnerFactory` providing a factory method for creating `CheckpointResourcesCleanupRunner` instances.
CheckpointResponder	Responder for checkpoint acknowledge and decline messages in the `Task`.
CheckpointRetentionPolicy	Policy for whether checkpoints are retained after a job terminates.
Checkpoints	A utility class with the methods to write/load/dispose the checkpoint and savepoint metadata.
CheckpointScheduling	`CheckpointScheduling` provides methods for starting and stopping the periodic scheduling of checkpoints.
CheckpointsCleaner	Delegate class responsible for checkpoints cleaning and counting the number of checkpoints yet to clean.
CheckpointStateOutputStream	A dedicated output stream that produces a `StreamStateHandle` when closed.
CheckpointStateToolset	A toolset of operations that can be performed on a location embedded within the class.
CheckpointStatisticDetailsHandler	REST handler which returns the details for a checkpoint.
CheckpointStatisticDetailsHeaders	Headers for the `CheckpointStatisticDetailsHandler`.
CheckpointStatistics	Statistics for a checkpoint.
CheckpointStatistics.CompletedCheckpointStatistics	Statistics for a completed checkpoint.
CheckpointStatistics.FailedCheckpointStatistics	Statistics for a failed checkpoint.
CheckpointStatistics.PendingCheckpointStatistics	Statistics for a pending checkpoint.
CheckpointStatsCache	A size-based cache of accessed checkpoints for completed and failed checkpoints.
CheckpointStatsCounts	Counts of checkpoints.
CheckpointStatsHistory	An array based history of checkpoint stats.
CheckpointStatsListener	An interface that allows listening on the checkpoint lifecycle.
CheckpointStatsSnapshot	A snapshot of the checkpoint stats.
CheckpointStatsStatus	Status of the tracked checkpoint.
CheckpointStatsTracker	Tracker for checkpoint statistics.
CheckpointStatusHeaders	These headers define the protocol for querying the status of a checkpoint operation.
CheckpointStatusMessageParameters	The parameters for triggering a checkpoint.
CheckpointStorage	CheckpointStorage defines how `StateBackend`'s store their state for fault tolerance in streaming applications.
CheckpointStorageAccess	Implementations of this interface should implement methods acting as an administration role for checkpoint storage, which defined in `CheckpointStorageCoordinatorView`.
CheckpointStorageCoordinatorView	This interface creates a `CheckpointStorageLocation` to which an individual checkpoint or savepoint is stored.
CheckpointStorageFactory<T extends CheckpointStorage>	A factory to create a specific `CheckpointStorage`.
CheckpointStorageLoader	This class contains utility methods to load checkpoint storage from configurations.
CheckpointStorageLocation	A storage location for one particular checkpoint, offering data persistent, metadata persistence, and lifecycle/cleanup methods.
CheckpointStorageLocationReference	A reference to a storage location.
CheckpointStorageWorkerView	This interface implements the durable storage of checkpoint data and metadata streams.
CheckpointStoreUtil	`CompletedCheckpointStore` utility interfaces.
CheckpointStreamFactory	A factory for checkpoint output streams, which are used to persist data for checkpoints.
CheckpointStreamWithResultProvider	Interface that provides access to a CheckpointStateOutputStream and a method to provide the `SnapshotResult`.
CheckpointStreamWithResultProvider.KeyedStateHandleFactory	Factory method for a `KeyedStateHandle` to be used in `CheckpointStreamWithResultProvider.toKeyedStateHandleSnapshotResult(SnapshotResult, KeyGroupRangeOffsets, KeyedStateHandleFactory)`.
CheckpointStreamWithResultProvider.PrimaryAndSecondaryStream	Implementation of `CheckpointStreamWithResultProvider` that creates both, the primary/remote/jm-owned state and the secondary/local/tm-owned state.
CheckpointStreamWithResultProvider.PrimaryStreamOnly	Implementation of `CheckpointStreamWithResultProvider` that only creates the primary/remote/jm-owned state.
CheckpointTriggerHeaders	These headers define the protocol for triggering a checkpoint.
CheckpointTriggerMessageParameters	The parameters for triggering a checkpoint.
CheckpointTriggerRequestBody	`RequestBody` to trigger checkpoints.
CheckpointType	The type of checkpoint to perform.
CleanupRetryStrategyFactory	`CleanupRetryStrategyFactory` is used to create the `RetryStrategy` for the `DispatcherResourceCleanerFactory`.
CleanupRunnerFactory	`CleanupRunnerFactory` provides a factory method for creating `CheckpointResourcesCleanupRunner` instances.
ClientAndIterator<E>	A pair of an `Iterator` to receive results from a streaming application and a `JobClient` to interact with the program.
ClientCoordinationHandler	Handler that receives the coordination requests from the client and returns the response from the coordinator.
ClientCoordinationHeaders	Message headers for the `ClientCoordinationHandler`.
ClientCoordinationMessageParameters	`MessageParameters` for `ClientCoordinationHandler`.
ClientCoordinationRequestBody	Request that carries a serialized `CoordinationRequest` to a specified coordinator.
ClientCoordinationResponseBody	Response that carries a serialized `CoordinationResponse` to the client.
ClientHighAvailabilityServices	`ClientHighAvailabilityServices` provides services those are required on client-side.
ClientHighAvailabilityServicesFactory	Factory interface for `ClientHighAvailabilityServices`.
ClientUtils	Contains utility methods for clients.
CloseableInputProvider<E>	Utility interface for a provider of an input that can be closed.
ClusterConfigHandler	Handler which serves the cluster's configuration.
ClusterConfiguration	Configuration class which contains the parsed command line arguments for the `ClusterEntrypoint`.
ClusterConfigurationInfoHeaders	Message headers for the `ClusterConfigHandler`.
ClusterConfigurationParserFactory	Parser factory which generates a `ClusterConfiguration` from the given list of command line arguments.
ClusterDatasetCorruptedException	Indicates some task fail to consume cluster dataset.
ClusterDataSetDeleteHandlers	Handler for `ClusterDataSetDeleteTriggerHeaders`.
ClusterDataSetDeleteHandlers.SerializableVoid	A `Void` alternative that implements `Serializable`.
ClusterDataSetDeleteStatusHeaders	Specification for retrieving the status for the delete operation of a cluster data set.
ClusterDataSetDeleteStatusMessageParameters	`MessageParameters` for the `ClusterDataSetDeleteStatusHeaders`.
ClusterDataSetDeleteTriggerHeaders	Specification for triggering the deletion of a cluster data set.
ClusterDataSetDeleteTriggerMessageParameters	`MessageParameters` for the `ClusterDataSetDeleteTriggerHeaders`.
ClusterDataSetEntry	The entry for a single cluster data set.
ClusterDataSetIdPathParameter	Path parameter identifying cluster data sets.
ClusterDataSetListHandler	Handler for `ClusterDataSetListHeaders`.
ClusterDataSetListHeaders	Specification for retrieving an overview over all available cluster partitions.
ClusterDataSetListResponseBody	`ResponseBody` for `ClusterDataSetListHeaders`.
ClusterEntrypoint	Base class for the Flink cluster entry points.
ClusterEntrypoint.ExecutionMode	Execution mode of the dispatcher.
ClusterEntrypoint.ShutdownBehaviour	Shutdown behaviour of a `ClusterEntrypoint`.
ClusterEntrypointException	Exceptions thrown by the `ClusterEntrypoint`.
ClusterEntryPointExceptionUtils	Exception utils to handle and enrich exceptions occurring in the ClusterEntrypoint.
ClusterEntrypointUtils	Utility class for `ClusterEntrypoint`.
ClusterInformation	Information about the cluster which is shared with the cluster components.
ClusterOverview	Response to the `RequestStatusOverview` message, carrying a description of the Flink cluster status.
ClusterOverviewHandler	Handler which returns the cluster overview information with version.
ClusterOverviewHeaders	Message headers for the `ClusterOverviewHandler`.
ClusterOverviewWithVersion	Cluster overview message including the current Flink version and commit id.
ClusterPartitionManager	Interface for components that manage cluster partitions.
ClusterPartitionReport	A report about the current status of all cluster partitions of the TaskExecutor, describing which partitions are available.
ClusterPartitionReport.ClusterPartitionReportEntry	An entry describing all partitions belonging to one dataset.
ClusterResourceStatisticsProvider	Provides statistics of cluster resources.
ClusterUncaughtExceptionHandler	Utility for handling any uncaught exceptions
CoBroadcastWithKeyedOperator<KS,IN1,IN2,OUT>	A `TwoInputStreamOperator` for executing `KeyedBroadcastProcessFunctions`.
CoBroadcastWithNonKeyedOperator<IN1,IN2,OUT>	A `TwoInputStreamOperator` for executing `BroadcastProcessFunctions`.
CoFlatMapFunction<IN1,IN2,OUT>	A CoFlatMapFunction implements a flat-map transformation over two connected streams.
CoGroupDriver<IT1,IT2,OT>	CoGroup task which is executed by a Task Manager.
CoGroupedStreams<T1,T2>	`CoGroupedStreams` represents two `DataStreams` that have been co-grouped.
CoGroupedStreams.UnionSerializer<T1,T2>	`TypeSerializer` for `TaggedUnion`.
CoGroupedStreams.UnionSerializerSnapshot<T1,T2>	The `TypeSerializerSnapshot` for the `CoGroupedStreams.UnionSerializer`.
CoGroupedStreams.WithWindow<T1,T2,KEY,W extends Window>	A co-group operation that has `KeySelectors` defined for both inputs as well as a `WindowAssigner`.
CoGroupRawDriver<IT1,IT2,OT>
CoGroupRawDriver.SimpleIterable<IN>
CoGroupTaskIterator<T1,T2>	Interface describing the methods that have to be implemented by local strategies for the CoGroup Pact.
CoGroupWithSolutionSetFirstDriver<IT1,IT2,OT>
CoGroupWithSolutionSetSecondDriver<IT1,IT2,OT>
CollectCoordinationRequest	A `CoordinationRequest` from the client indicating that it wants a new batch of query results.
CollectCoordinationResponse	A `CoordinationResponse` from the coordinator containing the required batch or new results and other necessary information in serialized form.
CollectResultFetcher<T>	A fetcher which fetches query results from sink and provides exactly-once semantics.
CollectResultIterator<T>	An iterator which iterates through the results of a query job.
CollectSinkAddressEvent	An `OperatorEvent` that passes the socket server address in the sink to the coordinator.
CollectSinkFunction<IN>	A sink function that collects query results and sends them back to the client.
CollectSinkOperator<IN>	A `StreamSink` that collects query results and sends them back to the client.
CollectSinkOperatorCoordinator	`OperatorCoordinator` for `CollectSinkFunction`.
CollectSinkOperatorCoordinator.Provider	Provider for `CollectSinkOperatorCoordinator`.
CollectSinkOperatorFactory<IN>	The Factory class for `CollectSinkOperator`.
CollectStreamSink<T>	A `DataStreamSink` which is used to collect results of a data stream.
CoLocationConstraint	A `CoLocationConstraint` stores the ID of `CoLocationGroup` and an ID referring to the actual subtask (i.e.
CoLocationGroup	`CoLocationGroup` refers to a list of `JobVertex` instances, where the i-th subtask of one vertex has to be executed on the same `TaskManager` as the i-th subtask of all other `JobVertex` instances in the same group.
CoLocationGroupImpl	A `CoLocationGroup` implementation.
CoMapFunction<IN1,IN2,OUT>	A CoFlatMapFunction implements a map() transformation over two connected streams.
CommandLineOptions	Container class for command line options.
CommandLineParser<T>	Command line parser which produces a result from the given command line arguments.
CommitRequestImpl<CommT>	Internal implementation to commit a specific committable and handle the response.
CommitRequestState	Internal state of a committable.
CommittableCollector<CommT>	This class is responsible to book-keep the committing progress across checkpoints and upstream subtasks.
CommittableCollectorSerializer<CommT>	The serializer for the `CommittableCollector`.
CommittableMessage<CommT>	The message send from `SinkWriter` to `Committer`.
CommittableMessageSerializer<CommT>	The serializer to serialize `CommittableMessage`s in custom operators.
CommittableMessageTypeInfo<CommT>	The type information for the `CommittableMessage` to make it consumable from a `DataStream`.
CommittableSummary<CommT>	This class tracks the information about committables belonging to one checkpoint coming from one subtask.
CommittableWithLineage<CommT>	Provides metadata.
CommitterOperatorFactory<CommT>	A `StreamOperatorFactory` for `CommitterOperator`.
CommonProcessMemorySpec<FM extends FlinkMemory>	Common memory components of Flink processes (e.g.
CompactingHashTable<T>	A hash table that uses Flink's managed memory and supports replacement of records or updates to records.
ComparableAggregator<T>	An `AggregationFunction` that computes values based on comparisons of `Comparables`.
Comparator	Internal comparator implementation, for use with `ComparableAggregator`.
CompletedCheckpoint	A CompletedCheckpoint describes a checkpoint after all required tasks acknowledged it (with their state) and that is considered successful.
CompletedCheckpointStats	Statistics for a successfully completed checkpoint.
CompletedCheckpointStatsSummary	Summary over all completed checkpoints.
CompletedCheckpointStatsSummarySnapshot	Immutable snapshot of `CompletedCheckpointStatsSummary`.
CompletedCheckpointStorageLocation	The CompletedCheckpointStorageLocation describes the storage aspect of a completed checkpoint.
CompletedCheckpointStore	A bounded LIFO-queue of `CompletedCheckpoint` instances.
CompletedOperationCache<K extends OperationKey,R extends Serializable>	Cache to manage ongoing operations.
CompleteStateIterator<T>	A `StateIterator` that has all elements.
ComponentClosingUtils	A util class to help with a clean component shutdown.
ComponentMetricGroup<P extends AbstractMetricGroup<?>>	Abstract `MetricGroup` for system components (e.g., TaskManager, Job, Task, Operator).
CompositeBuffer	An implementation of `Buffer` which contains multiple partial buffers for network data communication.
CompositeKeySerializationUtils	Utils for RocksDB state serialization and deserialization.
CompositeStateHandle	Base of all snapshots that are taken by `StateBackend`s and some other components in tasks.
CompressibleFSDataInputStream	`FSDataInputStream` that delegates all reading operations to a wrapping `StreamCompressionDecorator`.
CompressibleFSDataOutputStream	`FSDataOutputStream` that delegates all writing operations to a wrapping `StreamCompressionDecorator`.
CompressorUtils	Utils for `BlockCompressor`.
ConfigurableCheckpointStorage	An interface for checkpoint storage types that pick up additional parameters from a configuration.
ConfigurableStateBackend	An interface for state backends that pick up additional parameters from a configuration.
ConfigurableStreamPartitioner	Interface for `StreamPartitioner` which have to be configured with the maximum parallelism of the stream transformation.
ConfigurationCommandLineOptions	Represents the set of command-line options related to update and get configuration.
ConfigurationInfo	Response of the `ClusterConfigHandler`, represented as a list of key-value pairs of the cluster `Configuration`.
ConfigurationInfoEntry	A single key-value pair entry in the `ConfigurationInfo` response.
ConfigurationNotAllowedMessage	If `DeploymentOptions.PROGRAM_CONFIG_ENABLED` is disabled, this error denotes the not allowed configuration.
ConfigurationParserUtils	Utility class to extract related parameters from `Configuration` and to sanity check them.
ConnectedStreams<IN1,IN2>	ConnectedStreams represent two connected streams of (possibly) different data types.
ConnectionClosedException	Exception which is thrown if the `RestClient` detects that a connection was closed.
ConnectionErrorMessage	Message for indicating connection error.
ConnectionException	Base class for all connection related exception thrown by the `RestClient`.
ConnectionID	A `ConnectionID` identifies a connection to a remote task manager by the socket address and a connection index.
ConnectionIdleException	Exception which is thrown by the `RestClient` if a connection becomes idle.
ConnectionManager	The connection manager manages physical connections for the (logical) remote input channels at runtime.
ConnectionUtils	Utilities to determine the network interface and address that should be used to bind the TaskManager communication to.
ConnectionUtils.LeaderConnectingAddressListener	A `LeaderRetrievalListener` that allows retrieving an `InetAddress` for the current leader.
ConsumedPartitionGroup	Group of consumed `IntermediateResultPartitionID`s.
ConsumerRegionGroupExecutionView	This view maintains the finished progress of consumer `SchedulingPipelinedRegion`s for each `ConsumedPartitionGroup`.
ConsumerVertexGroup	Group of consumer `ExecutionVertexID`s.
ContaineredTaskManagerParameters	This class describes the basic parameters for launching a TaskManager process.
ContainingTaskDetails	Details about the operator containing task (such as `StreamTask`).
ContextStateFutureImpl<T>	A state future that holds the `RecordContext` and maintains the reference count of it.
ContextVariable<T>	A value that will have different values across different contexts.
ContinuousFileMonitoringFunction<OUT>	Deprecated. This class is based on the `SourceFunction` API, which is due to be removed.
ContinuousFileReaderOperator<OUT,T extends TimestampedInputSplit>	The operator that reads the `splits` received from the preceding `ContinuousFileMonitoringFunction`.
ContinuousFileReaderOperatorFactory<OUT,T extends TimestampedInputSplit>	`ContinuousFileReaderOperator` factory.
ConversionException	Exception which is thrown if an input cannot be converted into the requested type.
CoordinatedOperatorFactory<OUT>	A factory class for the `StreamOperator`s implementing `OperatorEventHandler`.
CoordinatedTask	An task that is coordinated, i.e. contains operators coordinated by `OperatorCoordinator`.
CoordinationRequest	Root interface for all requests from the client to a `OperatorCoordinator` which requests for a `CoordinationResponse`.
CoordinationRequestGateway	Client interface which sends out a `CoordinationRequest` and expects for a `CoordinationResponse` from a `OperatorCoordinator`.
CoordinationRequestHandler	Coordinator interface which can handle `CoordinationRequest`s and response with `CoordinationResponse`s to the client or operator.
CoordinationResponse	Root interface for all responses from a `OperatorCoordinator` to the client which is the response for a `CoordinationRequest`.
CoordinatorStore	`CoordinatorStore` can be used for sharing some information among `OperatorCoordinator` instances.
CoordinatorStoreImpl	Basic implementation of `CoordinatorStore`.
CoProcessFunction<IN1,IN2,OUT>	A function that processes elements of two streams and produces a single output one.
CoProcessOperator<IN1,IN2,OUT>	A `StreamOperator` for executing `CoProcessFunctions`.
CopyOnWriteStateMap<K,N,S>	Implementation of Flink's in-memory state maps with copy-on-write support.
CopyOnWriteStateMap.StateMapEntry<K,N,S>	One entry in the `CopyOnWriteStateMap`.
CopyOnWriteStateMapSnapshot<K,N,S>	This class represents the snapshot of a `CopyOnWriteStateMap`.
CopyOnWriteStateTable<K,N,S>	This implementation of `StateTable` uses `CopyOnWriteStateMap`.
CopyOnWriteStateTableSnapshot<K,N,S>	This class represents the snapshot of a `CopyOnWriteStateTable` and has a role in operator state checkpointing.
CorruptConfigurationException	Exception indicating that the parsed configuration was corrupt.
CoStreamFlatMap<IN1,IN2,OUT>	`StreamOperator` for processing `CoFlatMapFunctions`.
CoStreamMap<IN1,IN2,OUT>	`StreamOperator` for processing `CoMapFunctions`.
CountEvictor<W extends Window>	An `Evictor` that keeps up to a certain amount of elements.
CountingCollector<OUT>
CountingIterable<IN>
CountingIterator<IN>
CountingMutableObjectIterator<IN>
CountingOutput<OUT>	Wrapping `Output` that updates metrics on the number of emitted elements.
CountTrigger<W extends Window>	A `Trigger` that fires once the count of elements in a pane reaches the given count.
CreatingExecutionGraph	State which waits for the creation of the `ExecutionGraph`.
CreditBasedInputBuffersUsageGauge	Gauge metric measuring the input buffers usage for `SingleInputGate`s under credit based mode.
CrossDriver<T1,T2,OT>	Cross task which is executed by a Task Manager.
CuratorFrameworkWithUnhandledErrorListener	A wrapper for curatorFramework and unHandledErrorListener which should be unregister from curatorFramework before closing it.
CustomHeadersDecorator<R extends RequestBody,P extends ResponseBody,M extends MessageParameters>	Decorator class for `MessageHeaders` that adds the ability to include custom HTTP headers.
CustomPartitionerWrapper<K,T>	Partitioner that selects the channel with a user defined partitioner function on a key.
CustomSinkOperatorUidHashes	This class is responsible to hold operator Uid hashes from the common operators of the sink.
CustomSinkOperatorUidHashes.SinkOperatorUidHashesBuilder	Builder to construct `CustomSinkOperatorUidHashes`.
DamBehavior	Enumeration for the different dam behaviors of an algorithm or a driver strategy.
DashboardConfigHandler	Handler which returns the dashboard configuration.
DashboardConfiguration	Response of the `DashboardConfigHandler` containing general configuration values such as the time zone and the refresh interval.
DashboardConfiguration.Features	Collection of features that are enabled/disabled.
DashboardConfigurationHeaders	Message headers for the `DashboardConfigHandler`.
DataBuffer	Data of different subpartitions can be appended to a `DataBuffer` and after the `DataBuffer` is full or finished, the appended data can be copied from it in subpartition index order.
DataInputStatus	It is an internal equivalent of `InputStatus` that provides additional non public statuses.
DataSetMetaInfo	Container for meta-data of a data set.
DataSinkTask<IT>	DataSinkTask which is executed by a task manager.
DataSourceTask<OT>	DataSourceTask which is executed by a task manager.
DataStream<T>	A DataStream represents a stream of elements of the same type.
DataStream.Collector<T>	This class acts as an accessor to elements collected via `DataStream.collectAsync(Collector)`.
DataStreamSink<T>	A Stream Sink.
DataStreamSource<T>	The DataStreamSource represents the starting point of a DataStream.
DeactivatedCheckpointCompletedCheckpointStore	This class represents a `CompletedCheckpointStore` if checkpointing has been disabled.
DeactivatedCheckpointIDCounter	This class represents a `CheckpointIDCounter` if checkpointing is deactivated.
DeclarationChain<IN>	A declaration chain allows to declare multiple async operations in a single chain.
DeclarationContext	A context to declare parts of process in user-defined function/operator.
DeclarationException	Exception thrown when something wrong with declaration happens.
DeclarationManager	The manager holds all the declaration information and manage the building procedure.
DeclarativeSlotPool	Slot pool interface which uses Flink's declarative resource management protocol to acquire resources.
DeclarativeSlotPool.NewSlotsListener	Listener interface for newly available slots.
DeclarativeSlotPool.NoOpNewSlotsListener	No-op `DeclarativeSlotPool.NewSlotsListener` implementation.
DeclarativeSlotPoolBridge	`SlotPool` implementation which uses the `DeclarativeSlotPool` to allocate slots.
DeclarativeSlotPoolBridgeServiceFactory	Factory for `DeclarativeSlotPoolBridge`.
DeclarativeSlotPoolFactory	Factory for a `DeclarativeSlotPool`.
DeclarativeSlotPoolService	`SlotPoolService` implementation for the `DeclarativeSlotPool`.
DeclarativeSlotPoolServiceFactory	Factory for the `DeclarativeSlotPoolService`.
DeclaredVariable<T>	A variable declared in async state processing.
DeclareResourceRequirementServiceConnectionManager	`ServiceConnectionManager` for declaring resource requirements.
DeclareResourceRequirementServiceConnectionManager.DeclareResourceRequirementsService	Service that accepts resource requirements.
DeclaringAsyncKeyedProcessFunction<K,I,O>	A keyed function that processes elements of a stream.
DeclineCheckpoint	This message is sent from the `TaskExecutor` to the `JobMaster` to tell the checkpoint coordinator that a checkpoint request could not be heeded.
DeduplicatedQueue<T>	A basic queue with duplicated elements ignored during `DeduplicatedQueue.add(Object)`.
DefaultAdaptiveExecutionHandler	The `DefaultAdaptiveExecutionHandler` implements the `AdaptiveExecutionHandler` interface to provide an incrementally generated job graph.
DefaultAllocatedSlotPool	Default `AllocatedSlotPool` implementation.
DefaultBatchJobRecoveryHandler	Default implementation of `BatchJobRecoveryHandler` and `JobEventReplayHandler`.
DefaultBlocklistHandler	Default implementation of `BlocklistHandler`.
DefaultBlocklistHandler.Factory	The factory to instantiate `DefaultBlocklistHandler`.
DefaultBlocklistTracker	Default implementation of `BlocklistTracker`.
DefaultBroadcastVariableInitializer<T>	The default `BroadcastVariableInitializer` implementation that initializes the broadcast variable into a list.
DefaultCheckpointPlan	The default implementation of he `CheckpointPlan`.
DefaultCheckpointPlanCalculator	Default implementation for `CheckpointPlanCalculator`.
DefaultCheckpointStatsTracker
DefaultClientHighAvailabilityServicesFactory	Default factory for creating client high availability services.
DefaultCompletedCheckpointStore<R extends ResourceVersion<R>>	Default implementation of `CompletedCheckpointStore`.
DefaultCompletedCheckpointStoreUtils	Helper methods related to `DefaultCompletedCheckpointStore`.
DefaultDeclarativeSlotPool	Default `DeclarativeSlotPool` implementation.
DefaultDeclarativeSlotPoolFactory	Factory for `DefaultDeclarativeSlotPool`.
DefaultDelegationTokenManager	Manager for delegation tokens in a Flink cluster.
DefaultDelegationTokenManagerFactory	A factory for `DefaultDelegationTokenManager`.
DefaultDispatcherGatewayService	A facade over the `Dispatcher` that exposes specific functionality.
DefaultDispatcherResourceManagerComponentFactory	Abstract class which implements the creation of the `DispatcherResourceManagerComponent` components.
DefaultDispatcherRunner	Runner for the `Dispatcher` which is responsible for the leader election.
DefaultDispatcherRunnerFactory	`DispatcherRunnerFactory` implementation which creates `DefaultDispatcherRunner` instances.
DefaultExecutionDeployer	Default implementation of `ExecutionDeployer`.
DefaultExecutionDeployer.Factory	Factory to instantiate the `DefaultExecutionDeployer`.
DefaultExecutionDeploymentReconciler	Default `ExecutionDeploymentReconciler` implementation.
DefaultExecutionDeploymentTracker	Default `ExecutionDeploymentTracker` implementation.
DefaultExecutionGraph	Default implementation of the `ExecutionGraph`.
DefaultExecutionGraphBuilder	Utility class to encapsulate the logic of building an `DefaultExecutionGraph` from a `JobGraph`.
DefaultExecutionGraphCache	Default implementation of `ExecutionGraphCache`.
DefaultExecutionGraphFactory	Default `ExecutionGraphFactory` implementation.
DefaultExecutionOperations	Default implementation of `ExecutionOperations`.
DefaultExecutionPlanStore<R extends ResourceVersion<R>>	Default implementation for `ExecutionPlanStore`.
DefaultExecutionTopology	Adapter of `ExecutionGraph` to `SchedulingTopology`.
DefaultFailureEnricherContext	The default implementation of `FailureEnricher.Context` class.
DefaultFreeSlotTracker	Default implements of `FreeSlotTracker`.
DefaultGroupCache<G,K,V>	Default implement of `GroupCache`.
DefaultGroupCache.Factory<G,K,V>	The Factory of `DefaultGroupCache`.
DefaultHeartbeatMonitor<O>	The default implementation of `HeartbeatMonitor`.
DefaultInMemorySorterFactory<T>	Default factory for `InMemorySorter`.
DefaultInputConsumableDecider	Default implementation of `InputConsumableDecider`.
DefaultInputConsumableDecider.Factory	Factory for `DefaultInputConsumableDecider`.
DefaultJobLeaderIdService	Service which retrieves for a registered job the current job leader id (the leader id of the job manager responsible for the job).
DefaultJobLeaderService	Default implementation of `JobLeaderService`.
DefaultJobManagerJobMetricGroupFactory	Default implementation of `JobManagerJobMetricGroupFactory` which creates for a given `ExecutionPlan` a `JobManagerJobMetricGroup`.
DefaultJobManagerRunnerRegistry	`DefaultJobManagerRunnerRegistry` is the default implementation of the `JobManagerRunnerRegistry` interface.
DefaultJobMasterServiceFactory
DefaultJobMasterServiceProcess	Default `JobMasterServiceProcess` which is responsible for creating and running a `JobMasterService`.
DefaultJobMasterServiceProcessFactory
DefaultJobTable	Default implementation of the `JobTable`.
DefaultKeyedStateStore	Default implementation of KeyedStateStore that currently forwards state registration to a `RuntimeContext`.
DefaultLastStateConnectionStateListener	A simple ConnectionState listener that remembers the last state.
DefaultLeaderElectionService	Default implementation for leader election service.
DefaultLeaderRetrievalService	The counterpart to the `DefaultLeaderElectionService`.
DefaultLineageDataset	Default implementation for `LineageDataset`.
DefaultLineageEdge	Implementation of LineageEdge.
DefaultLineageGraph	Default implementation for `LineageGraph`.
DefaultLineageGraph.LineageGraphBuilder	Build the default lineage graph from `LineageEdge`.
DefaultLogicalEdge	Default implementation of `LogicalEdge`.
DefaultLogicalPipelinedRegion	Set of `LogicalVertex` that are connected through pipelined `LogicalResult`.
DefaultLogicalResult	Default implementation of `LogicalResult`.
DefaultLogicalTopology	Default implementation of `LogicalTopology`.
DefaultLogicalVertex	Default implementation of `LogicalVertex`.
DefaultMetricFilter	Default `MetricFilter` implementation that filters metrics based on `MetricOptions.REPORTER_INCLUDES`/`MetricOptions.REPORTER_EXCLUDES`.
DefaultOperatorCoordinatorHandler	Default handler for the `OperatorCoordinators`.
DefaultOperatorStateBackend	Default implementation of OperatorStateStore that provides the ability to make snapshots.
DefaultOperatorStateBackendBuilder	Builder class for `DefaultOperatorStateBackend` which handles all necessary initializations and clean ups.
DefaultPartitionWithMetrics	Default `PartitionWithMetrics` implementation.
DefaultPreferredLocationsRetriever	Default implementation of `PreferredLocationsRetriever`.
DefaultRequirementMatcher	Default implementation of `RequirementMatcher`.
DefaultResourceAllocationStrategy	The default implementation of `ResourceAllocationStrategy`.
DefaultResourceCleaner<T>	`DefaultResourceCleaner` is the default implementation of `ResourceCleaner`.
DefaultResourceCleaner.Builder<T>	`Builder` for creating `DefaultResourceCleaner` instances.
DefaultResourceTracker	Default `ResourceTracker` implementation.
DefaultScheduler	The future default scheduler.
DefaultSchedulerComponents	Components to create a `DefaultScheduler`.
DefaultSchedulerFactory	Factory for `DefaultScheduler`.
DefaultSchedulingPipelinedRegion	Default implementation of `SchedulingPipelinedRegion`.
DefaultShuffleMasterSnapshotContext	Default `ShuffleMasterSnapshotContext` implementation.
DefaultShuffleMetrics	Default `ShuffleMetrics` implementation.
DefaultSlotAssigner	Simple `SlotAssigner` that treats all slots and slot sharing groups equally.
DefaultSlotPoolServiceSchedulerFactory	Default `SlotPoolServiceSchedulerFactory` implementation.
DefaultSlotStatusSyncer	Default implementation of `SlotStatusSyncer` for fine-grained slot management.
DefaultSpeculativeExecutionHandler	The default implementation of `SpeculativeExecutionHandler`.
DefaultStateTransitionManager	`DefaultStateTransitionManager` is a state machine which manages the `AdaptiveScheduler`'s state transitions based on the previous transition time and the available resources.
DefaultStreamGraphContext	Default implementation for `StreamGraphContext`.
DefaultSubtaskAttemptNumberStore	Simple container for subtask attempt counts backed by a list.
DefaultTimerService<K>	Service to register timeouts for a given key.
DefaultVertexAttemptNumberStore	Maintains the attempt number per subtask.
DefaultVertexParallelismAndInputInfosDecider	Default implementation of `VertexParallelismAndInputInfosDecider`.
DefaultVertexParallelismInfo	A `VertexParallelismInformation` implementation that provides common validation.
DefaultVertexParallelismStore	Maintains the configured parallelisms for vertices, which should be defined by a scheduler.
DelegatingStateBackend	An interface to delegate state backend.
DelegationTokenContainer	Container for delegation tokens.
DelegationTokenManager	Manager for delegation tokens in a Flink cluster.
DelegationTokenManager.Listener	Listener for events in the `DelegationTokenManager`.
DelegationTokenReceiverRepository	Repository for delegation token receivers.
DeploymentStateTimeMetrics	Metrics that capture how long a job was deploying tasks.
DescriptiveStatisticsHistogram	The `DescriptiveStatisticsHistogram` use a DescriptiveStatistics `DescriptiveStatistics` as a Flink `Histogram`.
DescriptiveStatisticsHistogramStatistics	DescriptiveStatistics histogram statistics implementation returned by `DescriptiveStatisticsHistogram`.
DeserializationDelegate<T>	The deserialization delegate is used during deserialization to read an arbitrary element as if it implements `IOReadableWritable`, with the help of a type serializer.
DeterminismEnvelope<T>	Envelope that carries whether the wrapped value is deterministic or not.
DirectoryStateHandle	This state handle represents a directory.
DirectoryStreamStateHandle	This state handle represents a directory, usually used to be registered to `SharedStateRegistry` to track the life cycle of the directory.
DiskIOScheduler	The `DiskIOScheduler` is a scheduler that controls the reading of data from shuffle files.
DiskTierConsumerAgent	The data client is used to fetch data from disk tier.
DiskTierFactory	The implementation of `TierFactory` for disk tier.
DiskTierProducerAgent	The disk tier implementation of `TierProducerAgent`.
Dispatcher	Base class for the Dispatcher component.
Dispatcher.ExecutionType	Enum to distinguish between initial job submission and re-submission for recovery.
DispatcherBootstrap	An interface containing the logic of bootstrapping the `Dispatcher` of a cluster.
DispatcherBootstrapFactory	A factory to create a `DispatcherBootstrap`.
DispatcherCachedOperationsHandler	A handler for async operations triggered by the `Dispatcher` whose keys and results are cached.
DispatcherException	Base class for `Dispatcher` related exceptions.
DispatcherFactory	`Dispatcher` factory interface.
DispatcherGateway	Gateway for the Dispatcher component.
DispatcherId	Fencing token of the `Dispatcher`.
DispatcherLeaderProcessFactory	Factory for the `DispatcherLeaderProcess`.
DispatcherLeaderProcessFactoryFactory	Factory for `DispatcherLeaderProcessFactory`.
DispatcherOperationCaches	Encapsulates caches for results of asynchronous operations triggered by the `Dispatcher`.
DispatcherResourceCleanerFactory	`DispatcherResourceCleanerFactory` instantiates `ResourceCleaner` instances that clean cleanable resources from the `Dispatcher`.
DispatcherResourceManagerComponent	Component which starts a `Dispatcher`, `ResourceManager` and `WebMonitorEndpoint` in the same process.
DispatcherResourceManagerComponentFactory	Factory for the `DispatcherResourceManagerComponent`.
DispatcherRestEndpoint	REST endpoint for the `Dispatcher` component.
DispatcherRunner	The `DispatcherRunner` encapsulates how a `Dispatcher` is being executed.
DispatcherRunnerFactory	Factory interface for the `DispatcherRunner`.
DispatcherServices	`Dispatcher` services container.
DispatcherThreadFactory	Thread factory that creates threads with a given name, associates them with a given thread group, and set them to daemon mode.
DistributedRuntimeUDFContext	A standalone implementation of the `RuntimeContext`, created by runtime UDF operators.
DistributionPattern	A distribution pattern determines, which sub tasks of a producing task are connected to which consuming sub tasks.
DoneFuture<T>	A `Future` that is always done and will just yield the object that was given at creation time.
DownTimeGauge	A gauge that returns (in milliseconds) how long a job has not been not running any more, in case it is in a failing/recovering situation.
Driver<S extends org.apache.flink.api.common.functions.Function,OT>	The interface to be implemented by all drivers that run alone (or as the primary driver) in a task.
DriverStrategy	Enumeration of all available operator strategies.
DualKeyLinkedMap<A,B,V>	Map which stores values under two different indices.
DummyBatchJobRecoveryHandler	A dummy implementation of the `BatchJobRecoveryHandler`.
DummySpeculativeExecutionHandler	The dummy implementation of `SpeculativeExecutionHandler`.
DuplicateJobSubmissionException	Exception which is returned upon job submission if the submitted job is currently being executed.
DuplicatingCheckpointOutputStream	A CheckpointStateOutputStream that wraps a primary and a secondary CheckpointStateOutputStream and duplicates all writes into both streams.
DynamicConfiguration	A dynamic JAAS configuration.
DynamicParametersConfigurationParserFactory	`DynamicParametersConfigurationParserFactory` can be used to extract the dynamic parameters from command line.
EdgeManager	Class that manages all the connections between tasks.
EdgeManagerBuildUtil	Utilities for building `EdgeManager`.
ElementOrder	This enum defines the element order of being processed.
EmbeddedCompletedCheckpointStore	An embedded in-memory checkpoint store, which supports shutdown and suspend.
EmbeddedHaServices	An implementation of the `HighAvailabilityServices` for the non-high-availability case where all participants (ResourceManager, JobManagers, TaskManagers) run in the same process.
EmbeddedHaServicesWithLeadershipControl	`EmbeddedHaServices` extension to expose leadership granting and revoking.
EmbeddedJobResultStore	A thread-safe in-memory implementation of the `JobResultStore`.
EmbeddedLeaderService	A simple leader election service, which selects a leader among contenders and notifies listeners.
EmptyFileMergingOperatorStreamStateHandle	An empty `FileMergingOperatorStreamStateHandle` that is only used as a placeholder to prevent file merging directory from being deleted.
EmptyIterator<E>	An empty iterator that never returns anything.
EmptyMessageParameters	MessageParameters implementation which has no parameters.
EmptyMutableObjectIterator<E>	An empty mutable object iterator that never returns anything.
EmptyRequestBody	Request which do not have a request payload.
EmptyResponseBody	Empty `ResponseBody` implementation.
EmptySegmentFileStateHandle	An empty `SegmentFileStateHandle` that is only used as a placeholder.
EmptyShuffleMasterSnapshot	A singleton implementation of `ShuffleMasterSnapshot` that represents an empty snapshot of shuffle master.
EmptyTieredShuffleMasterSnapshot	A singleton implementation of `TieredShuffleMasterSnapshot` that represents an empty snapshot of tiered shuffle master.
EndOfChannelStateEvent	Marks the end of recovered state of `RecoveredInputChannel` of this subtask or `ResultSubpartition` on the upstream.
EndOfData	This event indicates there will be no more data records in a subpartition.
EndOfPartitionEvent	This event marks a subpartition as fully consumed.
EndOfSegmentEvent	`EndOfSegmentEvent` is used to notify the downstream switch tiers in tiered storage shuffle mode.
EndOfSuperstepEvent	Marks the end of a superstep of one particular iteration superstep.
EntrypointClusterConfiguration	Basic `ClusterConfiguration` for entry points.
EntrypointClusterConfigurationParserFactory	Parser factory for `EntrypointClusterConfiguration`.
Environment	The Environment gives the code executed in a task access to the task's properties (such as name, parallelism), the configurations, the data stream readers and writers, as well as the various components that are provided by the TaskManager, such as memory manager, I/O manager, ...
EnvironmentInfo	The response of environment info.
EnvironmentInformation	Utility class that gives access to the execution environment of the JVM, like the executing user, startup options, or the JVM version.
EnvironmentInformation.RevisionInformation	Revision information encapsulates information about the source code revision of the Flink code.
EpochManager	Epoch manager segments inputs into distinct epochs, marked by the arrival of non-records(e.g.
EpochManager.Epoch	All inputs are segment into distinct epochs, marked by the arrival of non-record inputs.
EpochManager.ParallelMode	This enum defines whether parallel execution between epochs is allowed.
ErrorInfo	Simple container to hold an exception and the corresponding timestamp.
ErrorResponseBody	Generic response body for communicating errors on the server.
EventAnnouncement	`EventAnnouncement` is announcing presence or receiving of an `AbstractEvent`.
EventListener<T>
EventSerializer	Utility class to serialize and deserialize task events.
EventTimeTrigger	A `Trigger` that fires once the watermark passes the end of the window to which a pane belongs.
EventTimeWatermarkCombiner	A `WatermarkCombiner` used to combine `EventTimeExtension` related watermarks in input channels.
EventTimeWatermarkHandler	This class is used to handle `EventTimeExtension` related watermarks in operator, such as `EventTimeExtension.EVENT_TIME_WATERMARK_DECLARATION` and `EventTimeExtension.IDLE_STATUS_WATERMARK_DECLARATION`.
EventTimeWatermarkHandler.EventTimeUpdateStatus	This class represents event-time updated status.
EvictingWindowOperator<K,IN,OUT,W extends Window>	A `WindowOperator` that also allows an `Evictor` to be used.
EvictingWindowOperatorFactory<K,IN,OUT,W extends Window>	`StreamOperatorFactory` for `EvictingWindowOperator`.
Evictor<T,W extends Window>	An `Evictor` can remove elements from a pane before/after the evaluation of WindowFunction and after the window evaluation gets triggered by a `Trigger`
Evictor.EvictorContext	A context object that is given to `Evictor` methods.
ExceptionHandler<E extends Throwable>	Interface to be implemented by classes that handle exceptions.
ExceptionHistoryEntry	`ExceptionHistoryEntry` collects information about a single failure that triggered the scheduler's failure handling.
ExceptionHistoryEntry.ArchivedTaskManagerLocation	`ArchivedTaskManagerLocation` represents a archived (static) version of a `TaskManagerLocation`.
ExceptionInChainedOperatorException	A special exception that signifies that the cause exception came from a chained operator.
ExceptionInChainedStubException	A special exception to indicate that an exception occurred in the nested call of a chained stub.
ExclusiveBuffersUsageGauge	Gauge metric measuring the exclusive buffers usage gauge for `SingleInputGate`s.
Execution	A single execution of a vertex.
ExecutionAttemptID	Unique identifier for the attempt to execute a tasks.
ExecutionDeployer	This deployer is responsible for deploying executions.
ExecutionDeployer.Factory	Factory to instantiate the `ExecutionDeployer`.
ExecutionDeploymentListener	A listener that is called when the deployment of an execution has been started/completed.
ExecutionDeploymentReconciler	Component for reconciling the deployment state of executions.
ExecutionDeploymentReconciler.Factory	Factory for `ExecutionDeploymentReconciler`.
ExecutionDeploymentReconciliationHandler	Interface for triggering actions in case of state mismatches.
ExecutionDeploymentReport	A report about the currently deployed executions of a TaskExecutor.
ExecutionDeploymentState	Possible states for the deployment of an execution.
ExecutionDeploymentTracker	A tracker for deployed executions.
ExecutionDeploymentTrackerDeploymentListenerAdapter	An adapter for using an `ExecutionDeploymentTracker` as an `ExecutionDeploymentListener`.
ExecutionFailureHandler	This handler deals with task failures to return a `FailureHandlingResult` which contains tasks to restart to recover from failures.
ExecutionGraph	The execution graph is the central data structure that coordinates the distributed execution of a data flow.
ExecutionGraphCache	Cache for `ExecutionGraphInfo` which are obtained from the Flink cluster.
ExecutionGraphCheckpointPlanCalculatorContext	A `CheckpointPlanCalculatorContext` implementation based on the information from an `ExecutionGraph`.
ExecutionGraphException	Base class for exceptions occurring in the `ExecutionGraph`.
ExecutionGraphException	Exceptions thrown by operations on the `ExecutionGraph` by the `JobMaster`.
ExecutionGraphFactory	Factory for creating an `ExecutionGraph`.
ExecutionGraphHandler	Handler for the `ExecutionGraph` which offers some common operations.
ExecutionGraphID	A class for statistically unique execution graph IDs.
ExecutionGraphInfo	`ExecutionGraphInfo` serves as a composite class that provides different `ExecutionGraph`-related information.
ExecutionGraphInfoStore	Interface for a `ExecutionGraphInfo` store.
ExecutionGraphResultPartitionAvailabilityChecker	A `ResultPartitionAvailabilityChecker` which decides the intermediate result partition availability based on whether the corresponding result partition in the execution graph is tracked.
ExecutionGraphToInputsLocationsRetrieverAdapter	An implementation of `InputsLocationsRetriever` based on the `ExecutionGraph`.
ExecutionGraphUtils	Utility methods related to `ExecutionGraph`.
ExecutionHistory	This class hosts the historical executions of an `ExecutionVertex` in a `LinkedHashMap` with a size bound.
ExecutionJobVertex	An `ExecutionJobVertex` is part of the `ExecutionGraph`, and the peer to the `JobVertex`.
ExecutionJobVertex.Factory	Factory to create `ExecutionJobVertex`.
ExecutionJobVertexFinishedEvent	This class is used to record the completion info of `ExecutionJobVertex`.
ExecutionJobVertexInitializedEvent	This class is used to record the initialization info of `ExecutionJobVertex`.
ExecutionOperations	Operations on the `Execution`.
ExecutionPlan	An interface representing a general execution plan, which can be implemented by different types of graphs such as JobGraph and StreamGraph.
ExecutionPlanSchedulingContext	Interface for retrieving stream graph context details for adaptive batch jobs.
ExecutionPlanStore	`ExecutionPlan` instances for recovery.
ExecutionPlanStore.ExecutionPlanListener	A listener for `ExecutionPlan` instances.
ExecutionPlanStoreUtil	ExecutionPlanStore utility interfaces.
ExecutionPlanStoreWatcher	A watcher on `ExecutionPlanStore`.
ExecutionPlanUtils	Utilities for generating `ExecutionPlan`.
ExecutionPlanWriter	Allows to store and remove execution plans.
ExecutionSlotAllocator	Component responsible for assigning slots to a collection of `Execution`.
ExecutionSlotAllocatorFactory	Interface for `ExecutionSlotAllocator` factories.
ExecutionSlotSharingGroup	Represents execution vertices that will run the same shared slot.
ExecutionState	An enumeration of all states that a task can be in during its execution.
ExecutionStateUpdateListener	A listener that is called when an execution switched to a new state.
ExecutionTimeBasedSlowTaskDetector	The slow task detector which detects slow tasks based on their execution time.
ExecutionVertex	The ExecutionVertex is a parallel subtask of the execution.
ExecutionVertexFinishedEvent	This class is used to record the state of `ExecutionVertex`.
ExecutionVertexID	Id identifying `ExecutionVertex`.
ExecutionVertexInputInfo	This class describe the inputs(partitions and subpartitions that belong to the same intermediate result) information of an execution vertex.
ExecutionVertexResetEvent	This class is used to record the `ExecutionVertex` that has been reset.
ExecutionVertexVersion	This class helps to record version of an execution vertex.
ExecutionVertexVersioner	Records modifications of `ExecutionVertices`, and allows for checking whether a vertex was modified.
ExecutorNotifier	This class is used to coordinate between two components, where one component has an executor following the mailbox model and the other component notifies it when needed.
ExponentialDelayRestartBackoffTimeStrategy	Restart strategy which tries to restart indefinitely number of times with an exponential backoff time in between.
ExponentialDelayRestartBackoffTimeStrategy.ExponentialDelayRestartBackoffTimeStrategyFactory	The factory for creating `ExponentialDelayRestartBackoffTimeStrategy`.
ExternallyInducedSource<T,CD>	Deprecated. This interface is based on the `SourceFunction` API, which is due to be removed.
ExternallyInducedSource.CheckpointTrigger	Through the `CheckpointTrigger`, the source function notifies the Flink source operator when to trigger the checkpoint.
ExternalResourceInfoProvider	Provide the information of external resources.
ExternalResourceUtils	Utility class for external resource framework.
ExternalSorter<E>	The `ExternalSorter` is a full fledged sorter.
ExternalSorterBuilder<T>	A builder for an `ExternalSorter`.
FailedCheckpointStats	Statistics for a failed checkpoint.
FailoverStrategy	New interface for failover strategies.
FailoverStrategy.Factory	The factory to instantiate `FailoverStrategy`.
FailoverStrategyFactoryLoader	A utility class to load NG failover strategy factories from the configuration.
FailureEnricherUtils	Utils class for loading and running pluggable failure enrichers.
FailureHandlingResult	Result containing the tasks to restart upon a task failure.
FailureHandlingResultSnapshot	`FailureHandlingResultSnapshot` creates a snapshot of a `FailureHandlingResult` providing the actual `Executions`.
FailureLabelFilterParameter	Specifies a collections of failure labels, filtering the exceptions returned for JobExceptionsHandler.
FailureLabelFilterParameter.FailureLabel	Represents a failure label consisting of a KV pair of strings.
FailureRateRestartBackoffTimeStrategy	Restart strategy which can restart when failure rate is not exceeded.
FailureRateRestartBackoffTimeStrategy.FailureRateRestartBackoffTimeStrategyFactory	The factory for creating `FailureRateRestartBackoffTimeStrategy`.
FailureResultUtil	`FailureResultUtil` contains helper methods for `FailureResult`.
FieldAccessor<T,F>	These classes encapsulate the logic of accessing a field specified by the user as either an index or a field expression string.
FieldAccessorFactory	Static factories for the `FieldAccessor` utilities.
FileBasedBufferIterator	`CloseableIterator` of `buffers` over file content.
FileBasedStateOutputStream	A `CheckpointStateOutputStream` that writes into a specified file and returns a `FileStateHandle` upon closing.
FileCache	The FileCache is used to access registered cache files when a task is deployed.
FileChannelInputView	A `DataInputView` that is backed by a `BlockChannelReader`, making it effectively a data input stream.
FileChannelManager	The manager used for creating/getting file IO channels based on config temp dirs.
FileChannelManagerImpl	The manager used for creating/deleting file channels based on config temp dirs.
FileChannelOutputView	A `DataOutputView` that is backed by a `BlockChannelWriter`, making it effectively a data output stream.
FileDataIndexCache<T extends FileDataIndexRegionHelper.Region>	A cache layer of hybrid data index.
FileDataIndexRegionHelper<T extends FileDataIndexRegionHelper.Region>	`FileDataIndexRegionHelper` is responsible for writing a `FileDataIndexRegionHelper.Region` to the file or reading a `FileDataIndexRegionHelper.Region` from file.
FileDataIndexRegionHelper.Region	A `FileDataIndexRegionHelper.Region` Represents a series of buffers that are: From the same subpartition Logically (i.e. buffer index) consecutive Physically (i.e. offset in the file) consecutive
FileDataIndexSpilledRegionManager<T extends FileDataIndexRegionHelper.Region>	This class is responsible for spilling region to disk and managing these spilled regions.
FileDataIndexSpilledRegionManager.Factory<T extends FileDataIndexRegionHelper.Region>	Factory of `FileDataIndexSpilledRegionManager`.
FileDataIndexSpilledRegionManagerImpl<T extends FileDataIndexRegionHelper.Region>	Default implementation of `FileDataIndexSpilledRegionManager`.
FileDataIndexSpilledRegionManagerImpl.Factory<T extends FileDataIndexRegionHelper.Region>	Factory of `FileDataIndexSpilledRegionManager`.
FileExecutionGraphInfoStore	Store for `ExecutionGraphInfo` instances.
FileIOChannel	A Channel represents a collection of files that belong logically to the same resource.
FileIOChannel.Enumerator	An enumerator for channels that logically belong together.
FileIOChannel.ID	An ID identifying an underlying file channel.
FileJobGraphRetriever	`JobGraphRetriever` implementation which retrieves the `JobGraph` from a file on disk.
FileMergingCheckpointStateOutputStream	A `CheckpointStateOutputStream` that writes into a segment of a file and returns a `SegmentFileStateHandle` upon closing.
FileMergingCheckpointStateOutputStream.FileMergingSnapshotManagerProxy	A proxy of the `FileMergingSnapshotManager` that owns this `FileMergingCheckpointStateOutputStream`, with the interfaces for dealing with physical files.
FileMergingMetricGroup	Metrics related to the file merging snapshot manager.
FileMergingOperatorStreamStateHandle	A `OperatorStreamStateHandle` that works for file merging checkpoints.
FileMergingSnapshotManager	FileMergingSnapshotManager provides an interface to manage files and meta information for checkpoint files with merging checkpoint files enabled.
FileMergingSnapshotManager.SpaceStat	Space usage statistics of a managed directory.
FileMergingSnapshotManager.SubtaskKey	A key identifies a subtask.
FileMergingSnapshotManagerBase	Base implementation of `FileMergingSnapshotManager`.
FileMergingSnapshotManagerBase.DirectoryHandleWithReferenceTrack	This class wrap DirectoryStreamStateHandle with reference count by ongoing checkpoint.
FileMergingSnapshotManagerBuilder	A builder that builds the `FileMergingSnapshotManager`.
FileMergingSnapshotManagerClosableWrapper	A wrapper that wraps `FileMergingSnapshotManager` and a `Closeable`.
FileMergingType	How the checkpoint files can be segmented.
FileMessageParameters	Parameters for `JobManagerCustomLogHandler`.
FileMonitoringFunction	Deprecated. Internal class deprecated in favour of `ContinuousFileMonitoringFunction`.
FileMonitoringFunction.WatchType	The watch type of the `FileMonitoringFunction`.
FileProcessingMode	The mode in which the `ContinuousFileMonitoringFunction` operates.
FileReadFunction	Deprecated. Internal class deprecated in favour of `ContinuousFileMonitoringFunction`.
FileRegionBuffer	This class represents a chunk of data in a file channel.
FileRegionWriteReadUtils	Utils for read and write `FileDataIndexRegionHelper.Region`.
FileSegment
FileSlotAllocationSnapshotPersistenceService	File based `SlotAllocationSnapshotPersistenceService` that persists the `SlotAllocationSnapshot` as local files.
FileStateHandle	`StreamStateHandle` for state that was written to a file stream.
FileSystemBlobStore	Blob store backed by `FileSystem`.
FileSystemCheckpointStorage	`FileSystemCheckpointStorage` checkpoints state as files to a file system.
FileSystemJobEventStore	Implementation of `JobEventStore` that stores all `JobEvent` instances in a `FileSystem`.
FileSystemJobResultStore	An implementation of the `JobResultStore` which persists job result data to an underlying distributed filesystem.
FileSystemStateStorageHelper<T extends Serializable>	`RetrievableStateStorageHelper` implementation which stores the state in the given filesystem path.
FileType	Different file types to request from the `TaskExecutor`.
FileUpload	Client uploading a file.
FileUploadHandler	Writes multipart/form-data to disk.
FileUploads	A container for uploaded files.
FineGrainedSlotManager	Implementation of `SlotManager` supporting fine-grained resource management.
FineGrainedTaskManagerRegistration	A FineGrainedTaskManagerRegistration represents a TaskManager.
FineGrainedTaskManagerSlot	A FineGrainedTaskManagerSlot represents a slot located in a TaskManager.
FineGrainedTaskManagerTracker	Implementation of `TaskManagerTracker` supporting fine-grained resource management.
FinishedDataOutput<IN>	An empty `PushingAsyncDataInput.DataOutput` which is used by `StreamOneInputProcessor` once an `DataInputStatus.END_OF_DATA` is received.
FinishedOnRestoreInput<IN>	A fake `Input` for finished on restore tasks.
FinishedOnRestoreMainOperatorOutput<OUT>	A fake main operator output that skips all the following operators for finished on restored tasks.
FinishedOperatorChain<OUT,OP extends StreamOperator<OUT>>	The `OperatorChain` that is used for restoring tasks that are `TaskStateManager.isTaskDeployedAsFinished()`.
FinishedOperatorSubtaskState	A specialized `OperatorSubtaskState` representing the subtask is finished.
FinishedTaskStateProvider	Collects and fulfills the finished state for the subtasks or operators.
FinishedTaskStateProvider.PartialFinishingNotSupportedByStateException	Thrown when some subtasks of the operator have been finished but state doesn't support that (e.g.
FixedDelayRestartBackoffTimeStrategy	Restart strategy which tries to restart a fixed number of times with a fixed backoff time in between.
FixedDelayRestartBackoffTimeStrategy.FixedDelayRestartBackoffTimeStrategyFactory	The factory for creating `FixedDelayRestartBackoffTimeStrategy`.
FixedLengthByteKeyAndValueComparator<INPUT>	The `FixedLengthByteKeyAndValueComparator` is used by `KeyedSortPartitionOperator` to compare records according to both the record key and record value.
FixedLengthRecordSorter<T>
FlameGraphTypeQueryParameter	Flame Graph type query parameter.
FlameGraphTypeQueryParameter.Type	Flame Graph type.
FlatMapDriver<IT,OT>	Map task which is executed by a Task Manager.
FlinkConfigLoader	Util class for loading configuration from commandline arguments.
FlinkHttpObjectAggregator	Same as `HttpObjectDecoder` but returns HTTP 413 to the client if the payload exceeds `MessageAggregator.maxContentLength`.
FlinkJobNotFoundException	Exception indicating that we could not find a Flink job with the given job ID.
FlinkJobTerminatedWithoutCancellationException	Exception indicating that the Flink job with the given job ID has terminated without cancellation.
FlinkMemory	Memory components which constitute the Total Flink Memory.
FlinkMemoryUtils<FM extends FlinkMemory>	Utility to derive the `FlinkMemory` components.
FlinkParseException	Exception which indicates that the parsing of command line arguments failed.
FlinkZooKeeperQuorumPeer	Simple wrapper for ZooKeeper's `QuorumPeer`, which reads a ZooKeeper config file and writes the required 'myid' file before starting the peer.
FloatingBuffersUsageGauge	Gauge metric measuring the floating buffers usage gauge for `SingleInputGate`s.
ForwardForConsecutiveHashPartitioner<T>	If there are multiple consecutive and the same hash shuffles, SQL planner will change them except the first one to use forward partitioner, so that these operators can be chained to reduce unnecessary shuffles.
ForwardForUnspecifiedPartitioner<T>	When the parallelism of both upstream and downstream is `ExecutionConfig.PARALLELISM_DEFAULT` and the edge's partitioner is not specified (partitioner==null), the edge's partitioner will be set to FORWARD by default(See `StreamGraph.createActualEdge(java.lang.Integer, java.lang.Integer, int, org.apache.flink.streaming.runtime.partitioner.StreamPartitioner<?>, org.apache.flink.util.OutputTag, org.apache.flink.streaming.api.transformations.StreamExchangeMode, org.apache.flink.runtime.jobgraph.IntermediateDataSetID)` method for details).
ForwardGroup<T>	A forward group is a set of job vertices or stream nodes connected via forward edges.
ForwardGroupComputeUtil	Common utils for computing forward groups.
ForwardingInputStream	Input stream, that wraps another input stream and forwards all method calls to the wrapped stream.
ForwardingOutputStream	`OutputStream`, that wraps another `OutputStream` and forwards all method calls to the wrapped stream.
ForwardPartitioner<T>	Partitioner that forwards elements only to the locally running downstream operation.
FreeingBufferRecycler	A simple buffer recycler that frees the memory segments.
FreeSlotFunction	A function for freeing slots.
FreeSlotTracker	Track all free slots.
FromElementsFunction<T>	Deprecated. This class is based on the `SourceFunction` API, which is due to be removed.
FromIteratorFunction<T>	Deprecated. This class is based on the `SourceFunction` API, which is due to be removed.
FromSplittableIteratorFunction<T>	Deprecated. This class is based on the `SourceFunction` API, which is due to be removed.
FrontMetricGroup<P extends AbstractMetricGroup<?>>	Metric group which forwards all registration calls to a variable parent metric group that injects a variable reporter index into calls to `MetricGroup.getMetricIdentifier(String)` or `MetricGroup.getMetricIdentifier(String, CharacterFilter)`.
FsCheckpointMetadataOutputStream	A `CheckpointMetadataOutputStream` that writes a specified file and directory, and returns a `FsCompletedCheckpointStorageLocation` upon closing.
FsCheckpointStateToolset	An implementation of `CheckpointStateToolset` that does file based duplicating with as `PathsCopyingFileSystem`.
FsCheckpointStorageAccess	An implementation of durable checkpoint storage to file systems.
FsCheckpointStorageLocation	A storage location for checkpoints on a file system.
FsCheckpointStreamFactory	A `CheckpointStreamFactory` that produces streams that write to a `FileSystem`.
FsCheckpointStreamFactory.FsCheckpointStateOutputStream	A `CheckpointStateOutputStream` that writes into a file and returns a `StreamStateHandle` upon closing.
FsCompletedCheckpointStorageLocation	A `CompletedCheckpointStorageLocation` that resides on a file system.
FSDataOutputStreamWrapper	Implementation of `MetadataOutputStreamWrapper` encapsulates the `FSDataOutputStream` for `FsCheckpointMetadataOutputStream`.
FsJobArchivist	Utility class for writing an archive file to a `FileSystem` and reading it back.
FsMergingCheckpointStorageAccess	An implementation of file merging checkpoint storage to file systems.
FsMergingCheckpointStorageLocation	An implementation of checkpoint storage location for file merging checkpoints.
FsSegmentDataInputStream	This class is a `WrappingProxy` for `FSDataInputStream` that is used to read from a file segment.
FullOuterJoinDriver<IT1,IT2,OT>	The full outer join driver implements the logic of an outer join operator at runtime.
FullSnapshotAsyncWriter<K>	An asynchronous writer that can write a full snapshot/savepoint from a `FullSnapshotResources`.
FullSnapshotResources<K>	A `SnapshotResources` to be used with the backend-independent `FullSnapshotAsyncWriter`.
FullSnapshotRestoreOperation<K>	The procedure of restoring state from a savepoint written with the unified binary format.
FullSnapshotUtil	Utility methods and constants around creating and restoring full snapshots using `FullSnapshotAsyncWriter`.
FullyFilledBuffer	An implementation of `Buffer` represents a fully filled buffer which contains multiple partial buffers for network data communication.
FullyFinishedOperatorState	A special operator state implementation representing the operators whose instances are all finished.
FunctionInitializationContext	This interface provides a context in which user functions can initialize by registering to managed state (i.e. state that is managed by state backends).
FunctionSnapshotContext	This interface provides a context in which user functions that use managed state (i.e. state that is managed by state backends) can participate in a snapshot.
GateBuffersSpec	The buffer specs of the `InputGate` include exclusive buffers per channel, required/total floating buffers and the target of total buffers.
GatewayRetriever<T extends org.apache.flink.runtime.rpc.RpcGateway>	Generic retriever interface for `RpcGateway`.
GaugePeriodTimer	Implementation of `PeriodTimer` based on `TimerGauge`.
GeneratedLogUrlHandler	Handler for retrieving the log url of a specified TaskManager or JobManager.
GenericJobEventSerializer	Serializer for `JobEvent` instances that uses Flink's `InstantiationUtil` for serialization and deserialization.
GenericKeyMetricGroup	A `GenericMetricGroup` for representing the key part of a key-value metric group pair.
GenericMetricGroup	A simple named `MetricGroup` that is used to hold subgroups of metrics.
GenericValueMetricGroup	A `GenericMetricGroup` for representing the value part of a key-value metric group pair.
GlobalAggregateManager	This interface gives access to transient, named, global aggregates.
GlobalCommitterOperator<CommT,GlobalCommT>	Implements the `GlobalCommitter`.
GlobalCommitterTransform<CommT>	Transformation for global committer.
GlobalCommitterTransformationTranslator<CommT>	A `TransformationTranslator` for the `GlobalCommitterOperator`.
GlobalFailureHandler	An interface for handling global failures.
GloballyCleanableResource	`GloballyCleanableResource` is supposed to be implemented by any class that provides artifacts for a given job that need to be cleaned up after the job reached a global terminal state.
GlobalPartitioner<T>	Partitioner that sends all elements to the downstream operator with subtask ID=0.
GlobalStreamExchangeMode	This mode decides the default `ResultPartitionType` of job edges.
GlobalWindow	The default window into which all data is placed (via `GlobalWindows`).
GlobalWindow.Serializer	A `TypeSerializer` for `GlobalWindow`.
GlobalWindow.Serializer.GlobalWindowSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
GlobalWindows	A `WindowAssigner` that assigns all elements to the same `GlobalWindow`.
GlobalWindows.EndOfStreamTrigger	A trigger that fires iff the input stream reaches EndOfStream.
GlobalWindows.NeverTrigger	A trigger that never fires, as default Trigger for GlobalWindows.
GroupCache<G,K,V>	This `GroupCache` can cache group, key and value.
GroupReduceCombineDriver<IN,OUT>	Non-chained combine driver which is used for a CombineGroup transformation or a GroupReduce transformation where the user supplied a RichGroupReduceFunction with a combine method.
GroupReduceDriver<IT,OT>	GroupReduce task which is executed by a Task Manager.
HadoopDelegationTokenConverter	Delegation token serializer and deserializer functionality.
HadoopDelegationTokenReceiver	Hadoop delegation token receiver base class.
HadoopDependency	Responsible telling if specific Hadoop dependencies are on classpath.
HadoopFSDelegationTokenProvider	Delegation token provider for Hadoop filesystems.
HadoopFSDelegationTokenReceiver	Delegation token receiver for Hadoop filesystems.
HadoopModule	Responsible for installing a Hadoop login user.
HadoopModuleFactory	A `SecurityModuleFactory` for `HadoopModule`.
HadoopSecurityContext	Hadoop security context which runs a Callable with the previously initialized UGI and appropriate security credentials.
HadoopSecurityContextFactory	Default security context factory that instantiates `SecurityContext` based on installed modules, it would instantiate `HadoopSecurityContext` if a `HadoopModuleFactory` is included.
HadoopUserUtils	Utility class for working with Hadoop user related classes.
HaLeadershipControl	Interface to grant and revoke leadership of HA components.
HandlerRedirectUtils	Utilities to extract a redirect address.
HandlerRequest<R extends RequestBody>	Simple container for the request to a handler, that contains the `RequestBody` and path/query parameters.
HandlerRequestException	Base class for all `HandlerRequest` related exceptions.
HandlerRequestUtils	Utils for getting query parameters from `HandlerRequest`.
HandlerUtils	Utilities for the REST handlers.
Hardware	Convenience class to extract hardware specifics of the computer executing the running JVM.
HardwareDescription	A hardware description describes the resources available to a task manager.
HaServicesJobPersistenceComponentFactory	`JobPersistenceComponentFactory` implementation which creates a `ExecutionPlanStore` using the provided `HighAvailabilityServices`.
HashBasedDataBuffer	* A `DataBuffer` implementation which sorts all appended records only by subpartition index.
HashBufferAccumulator	The hash implementation of the `BufferAccumulator`.
HashJoinIteratorBase	Common methods for all Hash Join Iterators.
HashMapStateBackend	This state backend holds the working state in the memory (JVM heap) of the TaskManagers and checkpoints based on the configured `CheckpointStorage`.
HashMapStateBackendFactory	A factory that creates an `HashMapStateBackend` from a configuration.
HashPartition<BT,PT>
HashPartition.BuildSideBuffer
HashPartitionIterator<BT,PT>	`Iterator` over the build side entries of a `HashPartition`.
HashSubpartitionBufferAccumulator	`HashSubpartitionBufferAccumulator` accumulates the records in a subpartition.
HashSubpartitionBufferAccumulatorContext	This interface is used by `HashSubpartitionBufferAccumulator` to operate `HashBufferAccumulator`.
HBaseDelegationTokenProvider	Delegation token provider implementation for HBase.
HBaseDelegationTokenReceiver	Delegation token receiver implementation for HBase.
HeaderlessChannelReaderInputView	A `DataInputView` that is backed by a `BlockChannelReader`, making it effectively a data input stream.
HeapBroadcastState<K,V>	A `Broadcast State` backed a heap-based `Map`.
HeapKeyedStateBackend<K>	A `AbstractKeyedStateBackend` that keeps state on the Java Heap and will serialize state to streams provided by a `CheckpointStreamFactory` upon checkpointing.
HeapKeyedStateBackendBuilder<K>	Builder class for `HeapKeyedStateBackend` which handles all necessary initializations and clean ups.
HeapKeyValueStateIterator	A `KeyValueStateIterator` over Heap backend snapshot resources.
HeapPriorityQueue<T extends HeapPriorityQueueElement>	Basic heap-based priority queue for `HeapPriorityQueueElement` objects.
HeapPriorityQueue<T extends HeapPriorityQueue.HeapPriorityQueueElement>	This class has similar functions with `HeapPriorityQueue`.
HeapPriorityQueue.HeapPriorityQueueElement	Interface for objects that can be managed by a `HeapPriorityQueue`.
HeapPriorityQueue.PriorityComparator<T>	This interface works similar to `Comparable` and is used to prioritize between two objects.
HeapPriorityQueueElement	Interface for objects that can be managed by a `HeapPriorityQueue`.
HeapPriorityQueueSet<T extends HeapPriorityQueueElement>	A heap-based priority queue with set semantics, based on `HeapPriorityQueue`.
HeapPriorityQueueSetFactory	Factory for `HeapPriorityQueueSet`.
HeapPriorityQueuesManager	Manages creating heap priority queues along with their counterpart meta info.
HeapPriorityQueueSnapshotRestoreWrapper<T extends HeapPriorityQueueElement>	This wrapper combines a HeapPriorityQueue with backend meta data.
HeapPriorityQueueStateSnapshot<T>	This class represents the snapshot of an `HeapPriorityQueueSet`.
HeapRestoreOperation<K>	Implementation of heap restore operation.
HeapSavepointRestoreOperation<K>	Implementation of heap savepoint restore operation.
HeapSort
HeartbeatListener<I,O>	Interface for the interaction with the `HeartbeatManager`.
HeartbeatManager<I,O>	A heartbeat manager has to be able to start/stop monitoring a `HeartbeatTarget`, and report heartbeat timeouts for this target.
HeartbeatMonitor<O>	Heartbeat monitor which manages the heartbeat state of the associated heartbeat target.
HeartbeatMonitor.Factory<O>	This factory provides an indirection way to create `HeartbeatMonitor`.
HeartbeatReceiver<I>	The receiver implementation of `HeartbeatTarget`, which mutes the `HeartbeatTarget#requestHeartbeat(ResourceID, I)`.
HeartbeatSender<I>	The sender implementation of `HeartbeatTarget`, which mutes the `HeartbeatTarget#receiveHeartbeat(ResourceID, I)`.
HeartbeatServices	HeartbeatServices gives access to all services needed for heartbeating.
HeartbeatServicesImpl	A default `HeartbeatServices` implementation.
HeartbeatTarget<I>	Interface for components which can be sent heartbeats and from which one can request a heartbeat response.
HighAvailabilityMode	High availability mode for Flink's cluster execution.
HighAvailabilityServices	The HighAvailabilityServices give access to all services needed for a highly-available setup.
HighAvailabilityServicesFactory	Factory interface for `HighAvailabilityServices`.
HighAvailabilityServicesUtils	Utils class to instantiate `HighAvailabilityServices` implementations.
HistoryServerArchivist	Writer for an `ExecutionGraphInfo`.
HistoryServerUtils	Utility class for the HistoryServer.
HttpHeader	Represents an HTTP header with a name and a value.
HttpMethodWrapper	This class wraps netty's `HttpMethod`s into an enum, allowing us to use them in switches.
IllegalExecutionStateException	A special `IllegalStateException` indicating a mismatch in the expected and actual `ExecutionState` of an `Execution`.
ImmutableStreamEdge	Helper class that provides read-only StreamEdge.
ImmutableStreamGraph	Helper class that provides read-only StreamGraph.
ImmutableStreamNode	Helper class that provides read-only StreamNode.
InboundChannelHandlerFactory	Custom netty inbound handler factory in order to make custom changes on netty inbound data.
IncompleteFuturesTracker	This tracker remembers CompletableFutures as long as they are incomplete and allows us to fail them later.
IncrementalKeyedStateHandle	Common interface to all incremental `KeyedStateHandle`.
IncrementalKeyedStateHandle.HandleAndLocalPath	A Holder of StreamStateHandle and the corresponding localPath.
IncrementalLocalKeyedStateHandle	State handle for local copies of `IncrementalRemoteKeyedStateHandle`.
IncrementalRemoteKeyedStateHandle	The handle to states of an incremental snapshot.
IndexedInputGate	An `InputGate` with a specific index.
IndexedSortable
IndexedSorter
IndexRange	This class represents the range of index.
IndexRangeUtil	Utils for `IndexRange`.
InflightDataRescalingDescriptor	Captures ambiguous mappings of old channels to new channels for a particular gate or partition.
InflightDataRescalingDescriptor.InflightDataGateOrPartitionRescalingDescriptor	Captures ambiguous mappings of old channels to new channels.
InflightDataRescalingDescriptor.InflightDataGateOrPartitionRescalingDescriptor.MappingType	Type of mapping which should be used for this in-flight data.
InfoMessage	Abstract base interface of all info messages exchanged between the JobManager an for example the runtime monitor.
InitializationStatus	Status of the initialization.
InitializationTypeConflictException	Indicates that a broadcast variable was initialized with a `DefaultBroadcastVariableInitializer` as a non-`List` type, and later accessed using `RuntimeContext.getBroadcastVariable(String)` which may only return lists.
InMemoryChangelogStateHandle	In-memory `ChangelogStateHandle`.
InMemoryPartition<T>	In-memory partition with overflow buckets for `CompactingHashTable`
InMemorySorter<T>
InMemorySorterFactory<T>	Factory for `InMemorySorter`.
InMemoryStateChangelogStorage	An in-memory (non-production) implementation of `StateChangelogStorage`.
InMemoryStateChangelogStorageFactory	An `StateChangelogStorageFactory` for creating `InMemoryStateChangelogStorage`.
InPlaceMutableHashTable<T>	This hash table supports updating elements.
Input<IN>	`Input` interface used in `MultipleInputStreamOperator`.
InputBuffersGauge	Gauge metric measuring the number of queued input buffers for `SingleInputGate`s.
InputBuffersSizeGauge	Gauge metric measuring the size in bytes of queued input buffers for `SingleInputGate`s.
InputChannel	An input channel consumes a single `ResultSubpartitionView`.
InputChannel.BufferAndAvailability	A combination of a `Buffer` and a flag indicating availability of further buffers, and the backlog length indicating how many non-event buffers are available in the subpartitions.
InputChannelID	Identifier for input channels.
InputChannelInfo	Identifies `InputChannel` in a given subtask.
InputChannelMetrics	Collects metrics for `RemoteInputChannel` and `LocalInputChannel`.
InputChannelStateHandle	`Handle` to an `InputChannel` state.
InputConsumableDecider	`InputConsumableDecider` is responsible for determining whether the input of an executionVertex or a consumed partition group is consumable.
InputConsumableDecider.Factory	Factory for `InputConsumableDecider`.
InputFormatOperatorFactory<OUT>	Input format source operator factory.
InputFormatSourceFunction<OUT>	Deprecated. This class is based on the `SourceFunction` API, which is due to be removed.
InputGate	An input gate consumes one or more partitions of a single produced intermediate result.
InputGate.InputWithData<INPUT,DATA>	Simple pojo for INPUT, DATA and moreAvailable.
InputGateDeploymentDescriptor	Deployment descriptor for a single input gate instance.
InputGateID	Runtime identifier of a consumed `IntermediateResult`.
InputGateMetrics	Collects metrics of an input gate.
InputGateSpecUtils	Utils to manage the specs of the `InputGate`, for example, `GateBuffersSpec`.
InputGateUtil	Utility for dealing with input gates.
InputGateWithMetrics	This class wraps `InputGate` provided by shuffle service and it is mainly used for increasing general input metrics from `TaskIOMetricGroup`.
InputOutputFormatContainer	A container for `InputFormats` and `OutputFormats`, along with their `Configuration`.
InputOutputFormatContainer.FormatUserCodeTable	Container for multiple wrappers containing `InputFormat` and `OutputFormat` code.
InputOutputFormatVertex	A task vertex that runs an initialization and a finalization on the master.
InputProcessorUtil	Utility for creating `CheckpointedInputGate` based on checkpoint mode for `StreamOneInputProcessor`.
InputSelectable	Interface for stream operators that can select the input to get `StreamRecord`.
InputSelection	Describe the input selection that stream operators want to read records.
InputSelection.Builder	Utility class for creating `InputSelection`.
InputsLocationsRetriever	Component to retrieve the inputs locations of an `ExecutionVertex`.
InputSplitProvider	An input split provider can be successively queried to provide a series of `InputSplit` objects a task is supposed to consume in the course of its execution.
InputSplitProviderException
InputViewIterator<E>
InstanceID	Class for statistically unique instance IDs.
IntArrayList	Minimal implementation of an array-backed list of ints
IntegerResourceVersion	`ResourceVersion` implementation with `Integer` value.
IntermediateDataSet	An intermediate data set is the data set produced by an operator - either a source or any intermediate operation.
IntermediateDataSetID	Id identifying `IntermediateDataSet`.
IntermediateResult
IntermediateResultInfo
IntermediateResultPartition
IntermediateResultPartitionID	Id identifying `IntermediateResultPartition`.
InternalAggregateProcessAllWindowFunction<T,ACC,V,R,W extends Window>	Internal window function for wrapping a `ProcessAllWindowFunction` that takes an `Iterable` and an `AggregateFunction`.
InternalAggregateProcessAsyncWindowFunction<T,ACC,V,R,K,W extends Window>	Internal window function for wrapping a `ProcessWindowFunction` that takes an `Iterable` and an `AggregateFunction`.
InternalAggregateProcessWindowFunction<T,ACC,V,R,K,W extends Window>	Internal window function for wrapping a `ProcessWindowFunction` that takes an `Iterable` and an `AggregateFunction`.
InternalAggregatingState<K,N,IN,SV,OUT>	The peer to the `AggregatingState` in the internal state type hierarchy.
InternalAggregatingState<K,N,IN,ACC,OUT>	This class defines the internal interface for aggregating state.
InternalAppendingState<K,N,IN,SV,OUT>	The peer to the `AppendingState` in the internal state type hierarchy.
InternalAppendingState<K,N,IN,SV,OUT,SYNCOUT>	This class defines the internal interface for appending state.
InternalAsyncWindowFunction<IN,OUT,KEY,W extends Window>	Internal interface for functions that are evaluated over keyed (grouped) windows.
InternalAsyncWindowFunction.InternalWindowContext	A context for `InternalAsyncWindowFunction`, similar to `ProcessWindowFunction.Context` but for internal use.
InternalBoolWatermarkDeclaration	The `InternalBoolWatermarkDeclaration` class implements the `AbstractInternalWatermarkDeclaration` interface and provides additional functionality specific to boolean-type watermarks.
InternalCacheMetricGroup	A `CacheMetricGroup` which register all cache related metrics under a subgroup of the parent metric group.
InternalExecutionGraphAccessor	This interface encapsulates all methods needed by ExecutionJobVertex / ExecutionVertices / Execution from the DefaultExecutionGraph.
InternalFailuresListener	This interface enables subscribing to failures that are detected from the JobMaster side (e.g., from within the `ExecutionGraph`).
InternalIterableAllWindowFunction<IN,OUT,W extends Window>	Internal window function for wrapping an `AllWindowFunction` that takes an `Iterable` when the window state also is an `Iterable`.
InternalIterableAsyncWindowFunction<IN,OUT,KEY,W extends Window>	Internal window function for wrapping a `WindowFunction` that takes an `Iterable` when the window state also is an `Iterable`.
InternalIterableProcessAllWindowFunction<IN,OUT,W extends Window>	Internal window function for wrapping a `ProcessAllWindowFunction` that takes an `Iterable` when the window state also is an `Iterable`.
InternalIterableProcessAsyncWindowFunction<IN,OUT,KEY,W extends Window>	Internal window function for wrapping a `ProcessWindowFunction` that takes an `Iterable` when the window state also is an `Iterable`.
InternalIterableProcessWindowFunction<IN,OUT,KEY,W extends Window>	Internal window function for wrapping a `ProcessWindowFunction` that takes an `Iterable` when the window state also is an `Iterable`.
InternalIterableWindowFunction<IN,OUT,KEY,W extends Window>	Internal window function for wrapping a `WindowFunction` that takes an `Iterable` when the window state also is an `Iterable`.
InternalKeyContext<K>	This interface is the current context of a keyed state.
InternalKeyContextImpl<K>	The default `InternalKeyContext` implementation.
InternalKeyedState<K,N,V>	This class defines the internal interface for all keyed state.
InternalKvState<K,N,V>	The `InternalKvState` is the root of the internal state type hierarchy, similar to the `State` being the root of the public API state hierarchy.
InternalKvState.StateIncrementalVisitor<K,N,V>	The state entry visitor which supports remove and update of the last returned entries.
InternalListState<K,N,T>	The peer to the `ListState` in the internal state type hierarchy.
InternalListState<K,N,V>	This class defines the internal interface for list state.
InternalLongWatermarkDeclaration	The `InternalLongWatermarkDeclaration` class implements the `AbstractInternalWatermarkDeclaration` interface and provides additional functionality specific to long-type watermarks.
InternalMapState<K,N,UK,UV>	The peer to the `MapState` in the internal state type hierarchy.
InternalMapState<K,N,UK,UV>	This class defines the internal interface for map state.
InternalMergingState<K,N,IN,SV,OUT>	The peer to the `MergingState` in the internal state type hierarchy.
InternalMergingState<K,N,IN,SV,OUT,SYNCOUT>	This class defines the internal interface for merging state.
InternalOperatorCoordinatorMetricGroup	Special `MetricGroup` representing an OperatorCoordinator.
InternalOperatorIOMetricGroup	Metric group that contains shareable pre-defined IO-related metrics.
InternalOperatorMetricGroup	Special `MetricGroup` representing an Operator.
InternalPartitionedState<N>	A state that is partitioned into different namespaces.
InternalPriorityQueue<T>	Interface for collection that gives in order access to elements w.r.t their priority.
InternalProcessAllWindowContext<IN,OUT,W extends Window>	Internal reusable context wrapper.
InternalProcessApplyAllWindowContext<IN,OUT,W extends Window>	Internal reusable context wrapper.
InternalProcessApplyWindowContext<IN,OUT,KEY,W extends Window>	Internal reusable context wrapper.
InternalProcessWindowContext<IN,OUT,KEY,W extends Window>	Internal context wrapper for async window operator.
InternalProcessWindowContext<IN,OUT,KEY,W extends Window>	Internal reusable context wrapper.
InternalReducingState<K,N,T>	The peer to the `ReducingState` in the internal state type hierarchy.
InternalReducingState<K,N,T>	This class defines the internal interface for reducing state.
InternalSingleValueAllWindowFunction<IN,OUT,W extends Window>	Internal window function for wrapping an `AllWindowFunction` that takes an `Iterable` when the window state is a single value.
InternalSingleValueAsyncWindowFunction<IN,OUT,KEY,W extends Window>	Internal window function for wrapping a `WindowFunction` that takes an `Iterable` when the window state is a single value.
InternalSingleValueProcessAllWindowFunction<IN,OUT,W extends Window>	Internal window function for wrapping a `ProcessAllWindowFunction` that takes an `Iterable` when the window state is a single value.
InternalSingleValueProcessAsyncWindowFunction<IN,OUT,KEY,W extends Window>	Internal window function for wrapping a `ProcessWindowFunction` that takes an `Iterable` when the window state is a single value.
InternalSingleValueProcessWindowFunction<IN,OUT,KEY,W extends Window>	Internal window function for wrapping a `ProcessWindowFunction` that takes an `Iterable` when the window state is a single value.
InternalSingleValueWindowFunction<IN,OUT,KEY,W extends Window>	Internal window function for wrapping a `WindowFunction` that takes an `Iterable` when the window state is a single value.
InternalSinkCommitterMetricGroup	Special `MetricGroup` representing an Operator.
InternalSinkWriterMetricGroup	Special `MetricGroup` representing an Operator.
InternalSourceReaderMetricGroup	Special `MetricGroup` representing an Operator.
InternalSplitEnumeratorMetricGroup	Special `MetricGroup` representing an `SplitEnumerator`.
InternalStateAccessible<SV>
InternalTimer<K,N>	Internal interface for in-flight timers.
InternalTimerService<N>	Interface for working with time and timers.
InternalTimerServiceAsyncImpl<K,N>	An implementation of `InternalTimerService` that is used by `AbstractAsyncStateStreamOperator`.
InternalTimerServiceImpl<K,N>	`InternalTimerService` that stores timers on the Java heap.
InternalTimerServiceSerializationProxy<K>	Serialization proxy for the timer services for a given key-group.
InternalTimersSnapshot<K,N>	A snapshot of internal timers, containing event and processing timers and the serializers to use to write / read them.
InternalTimersSnapshotReaderWriters	Readers and writers for different versions of the `InternalTimersSnapshot`.
InternalTimersSnapshotReaderWriters.InternalTimersSnapshotReader<K,N>	A reader for a `InternalTimersSnapshot`.
InternalTimersSnapshotReaderWriters.InternalTimersSnapshotWriter	A writer for a `InternalTimersSnapshot`.
InternalTimersSnapshotReaderWriters.LegacyTimerSerializer<K,N>	A `TypeSerializer` used to serialize/deserialize a `TimerHeapInternalTimer`.
InternalTimeServiceManager<K>	An entity keeping all the time-related services.
InternalTimeServiceManager.Provider	A provider pattern for creating an instance of a `InternalTimeServiceManager`.
InternalTimeServiceManager.ShouldStopAdvancingFn	Signals whether the watermark should continue advancing.
InternalTimeServiceManagerImpl<K>	An entity keeping all the time-related services.
InternalValueState<K,N,T>	The peer to the `ValueState` in the internal state type hierarchy.
InternalValueState<K,N,V>	This class defines the internal interface for value state.
InternalWatermark	The `Watermark` that contains extra information to be used internally.
InternalWindowFunction<IN,OUT,KEY,W extends Window>	Internal interface for functions that are evaluated over keyed (grouped) windows.
InternalWindowFunction.InternalWindowContext	A context for `InternalWindowFunction`, similar to `ProcessWindowFunction.Context` but for internal use.
IntervalJoinOperator<K,T1,T2,OUT>	An `operator` to execute time-bounded stream inner joins.
IntervalJoinOperator.BufferEntry<T>	A container for elements put in the left/write buffer.
IntervalJoinOperator.BufferEntrySerializer<T>	A `serializer` for the `IntervalJoinOperator.BufferEntry`.
IntervalJoinOperator.BufferEntrySerializerSnapshot<T>	A `TypeSerializerSnapshot` for `IntervalJoinOperator.BufferEntrySerializer`.
IOManager	The facade for the provided I/O manager services.
IOManagerAsync	A version of the `IOManager` that uses asynchronous I/O.
IOMetrics	An instance of this class represents a snapshot of the io-related metrics of a single task.
IOMetricsInfo	IO metrics information.
IsProcessingBacklogEvent	A source event that notify the source operator of the backlog status.
IsSlotAvailableAndFreeFunction	Functional interface for checking whether a slot is available and free.
IterableStateSnapshot<K,N,S>	A `StateSnapshot` that can return an iterator over all contained `StateEntries`.
IterationAggregatorBroker	`Broker` for `RuntimeAggregatorRegistry`.
IterationEventWithAggregators	Base class for iteration `TaskEvent` transmitting operator aggregators.
IterationHeadTask<X,Y,S extends org.apache.flink.api.common.functions.Function,OT>	The head is responsible for coordinating an iteration and can run a `Driver` inside.
IterationIntermediateTask<S extends org.apache.flink.api.common.functions.Function,OT>	An intermediate iteration task, which runs a `Driver` inside.
IterationSynchronizationSinkTask	The task responsible for synchronizing all iteration heads, implemented as an output task.
IterationTailTask<S extends org.apache.flink.api.common.functions.Function,OT>	An iteration tail, which runs a driver inside.
JaasModule	Responsible for installing a process-wide JAAS configuration.
JaasModuleFactory	A `SecurityModuleFactory` for `JaasModule`.
JavaSerializer<T extends Serializable>	A `TypeSerializer` that uses Java serialization.
JavaSerializer.JavaSerializerSnapshot<T extends Serializable>	Serializer configuration snapshot for compatibility and format evolution.
JMTMRegistrationRejection	Message indicating a registration rejection from the `JobMaster` for the `TaskExecutor`.
JMTMRegistrationSuccess	Message indicating a successful `JobMaster` and `TaskExecutor` registration.
JobAccumulatorsHandler	Request handler that returns the aggregated accumulators of a job.
JobAccumulatorsHeaders	Message headers for the `JobAccumulatorsHandler`.
JobAccumulatorsInfo	Response type of the `JobAccumulatorsHandler`.
JobAccumulatorsInfo.JobAccumulator	Json serializer for the `JobAccumulatorsInfo`.
JobAccumulatorsInfo.UserTaskAccumulator	Json serializer for the `JobAccumulatorsInfo`.
JobAccumulatorsMessageParameters	Request parameter for job accumulator's handler `JobAccumulatorsHandler`.
JobAllocationsInformation	Information about allocations of Job Vertices.
JobAllocationsInformation.VertexAllocationInformation	Information about the allocations of a single Job Vertex.
JobCancellationException	An exception which is thrown by the JobClient if a job is aborted as a result of a user cancellation.
JobCancellationFailedException	`JobCancellationFailedException` is thrown if the cancellation of a job failed.
JobCancellationHandler	Request handler for the cancel and stop request.
JobCancellationHeaders	Message headers for the `JobCancellationHandler`.
JobCancellationMessageParameters	Parameters for job related REST handlers.
JobCheckpointingSettings	The JobCheckpointingSettings are attached to a JobGraph and describe the settings for the asynchronous checkpoints of the JobGraph, such as interval.
JobClientHeartbeatHandler	Receive the heartbeat from the client.
JobClientHeartbeatHeaders	Message headers for the `JobClientHeartbeatHandler`.
JobClientHeartbeatParameters	The parameter when the client reports heartbeat.
JobClientHeartbeatRequestBody	`RequestBody` to report heartbeat for client.
JobConfigHandler	Handler serving the job configuration.
JobConfigHeaders	Message headers for the `JobConfigHandler`.
JobConfigInfo	Response type of the `JobConfigHandler`.
JobConfigInfo.Deserializer	Json deserializer for the `JobConfigInfo`.
JobConfigInfo.ExecutionConfigInfo	Nested class to encapsulate the execution configuration.
JobConfigInfo.Serializer	Json serializer for the `JobConfigInfo`.
JobDetails	An actor message with a detailed overview of the current status of a job.
JobDetails.CurrentAttempts	The CurrentAttempts holds the attempt number of the current representative execution attempt, the attempt numbers of all the running attempts, and whether the current execution has reached terminal state.
JobDetailsHandler	Handler returning the details for the specified job.
JobDetailsHeaders	Message headers for the `JobDetailsHandler`.
JobDetailsInfo	Details about a job.
JobDetailsInfo.JobVertexDetailsInfo	Detailed information about a job vertex.
JobEdge	This class represent edges (communication channels) in a job graph.
JobEvent	A class that represents an event that happens during the job execution.
JobEventManager	The manager for recording and replaying `JobEvent`.
JobEventReplayHandler	The interface for process job event.
JobEvents	A class hosts all the type ids of events.
JobEventStore	A store for recording the `JobEvent`.
JobException	Indicates that a job has failed.
JobExceptionsHandler	Handler serving the job exceptions.
JobExceptionsHeaders	Message headers for the `JobExceptionsHandler`.
JobExceptionsInfoWithHistory	`JobExceptionsInfoWithHistory` providing a history of previously caused failures.
JobExceptionsInfoWithHistory.ExceptionInfo	Json equivalent of `ExceptionHistoryEntry`.
JobExceptionsInfoWithHistory.JobExceptionHistory	`JobExceptionHistory` collects all previously caught errors.
JobExceptionsInfoWithHistory.RootExceptionInfo	Json equivalent of `RootExceptionHistoryEntry`.
JobExceptionsMessageParameters	`MessageParameters` for `JobExceptionsHandler`.
JobExecutionException	This exception is the base exception for all exceptions that denote any failure during the execution of a job.
JobExecutionResultHandler	Returns the `JobExecutionResult` for a given `JobID`.
JobExecutionResultHeaders	`MessageHeaders` for `JobExecutionResultHeaders`.
JobExecutionResultResponseBody	`ResponseBody` that carries a `QueueStatus` and a `JobResult`.
JobFailureMetricReporter	Helper class to simplify job failure reporting through a metric group.
JobGraph	The JobGraph represents a Flink dataflow program, at the low level that the JobManager accepts.
JobGraphBuilder	Builder for the `JobGraph`.
JobGraphJobInformation	`JobInformation` created from a `JobGraph`.
JobGraphRetriever	Interface which allows to retrieve the `JobGraph`.
JobGraphUpdateListener	This interface defines operations for components that are interested in being notified when new job vertices are added to the job graph.
JobIDDeserializer	Json deserializer for `JobID`.
JobIDPathParameter	Path parameter identifying jobs.
JobIDSerializer	Json serializer for `JobID`.
JobIdsHandler	Handler for job IDs.
JobIdsWithStatusesOverviewHeaders	Message headers for the `JobIdsWithStatusOverview`.
JobIdsWithStatusOverview	An overview of how many jobs are in which status.
JobIdsWithStatusOverview.JobIdWithStatus
JobInformation	Container class for job information which is stored in the `ExecutionGraph`.
JobInformation	Information about the job.
JobInformation.VertexInformation	Information about a single vertex.
JobInitializationException	An exception indicating that the job has failed in the INITIALIZING job status.
JobLeaderIdActions	Interface for actions called by the `DefaultJobLeaderIdService`.
JobLeaderIdService	Service which retrieves for a registered job the current job leader id (the leader id of the job manager responsible for the job).
JobLeaderListener	Listener for the `JobLeaderService`.
JobLeaderService	This service has the responsibility to monitor the job leaders (the job manager which is leader for a given job) for all registered jobs.
JobManagerCheckpointStorage	The `CheckpointStorage` checkpoints state directly to the JobManager's memory (hence the name), but savepoints will be persisted to a file system.
JobManagerCustomLogHandler	Rest handler which serves the custom log file from JobManager.
JobManagerCustomLogHeaders	Headers for the `JobManagerCustomLogHandler`.
JobManagerEnvironmentHandler	Handler which serves the jobmanager's environment variables.
JobManagerEnvironmentHeaders	Message headers for the `JobManagerEnvironmentHandler`.
JobManagerException	Base exception thrown by the `JobMaster`.
JobManagerFlinkMemory	Flink internal memory components of Job Manager.
JobManagerFlinkMemoryUtils	`FlinkMemoryUtils` for Job Manager.
JobManagerJobConfigurationHandler	Handler which serves the jobmanager's configuration of a specific job.
JobManagerJobConfigurationHeaders	Message headers for the `JobManagerJobConfigurationHandler`.
JobManagerJobEnvironmentHandler	Handler which serves the jobmanager's environment variables of a specific job.
JobManagerJobEnvironmentHeaders	Message headers for the `JobManagerJobEnvironmentHandler`.
JobManagerJobMetricGroup	Special `MetricGroup` representing everything belonging to a specific job, running on the JobManager.
JobManagerJobMetricGroupFactory	Factory interface for `JobManagerJobMetricGroup`.
JobManagerJobScopeFormat	The scope format for the `JobMetricGroup`.
JobManagerLogFileHandler	Rest handler which serves the log files from JobManager.
JobManagerLogFileHeader	Headers for the `JobManagerLogFileHandler`.
JobManagerLogListHandler	Handler which serves detailed JobManager log list information.
JobManagerLogListHeaders	Headers for the `JobManagerLogListHandler`.
JobManagerLogUrlHeaders	Headers for the log url retriever of JobManager.
JobManagerMetricGroup	Special `MetricGroup` representing a JobManager.
JobManagerMetricGroupFactory	Factory interface for `JobManagerMetricGroup`.
JobManagerMetricsHandler	Handler that returns JobManager metrics.
JobManagerMetricsHeaders	`MessageHeaders` for `JobManagerMetricsHandler`.
JobManagerMetricsMessageParameters	`MessageParameters` for `JobManagerMetricsHandler`.
JobManagerOperatorMetricGroup	Special `MetricGroup` representing everything belonging to the components running on the JobManager of an Operator.
JobManagerOperatorMetricsHandler	Handler that returns job manager operator metrics.
JobManagerOperatorMetricsHeaders	`MessageHeaders` for `JobManagerOperatorMetricsHandler`.
JobManagerOperatorMetricsMessageParameters	`MessageParameters` for `JobManagerOperatorMetricsHandler`.
JobManagerOperatorScopeFormat	The scope format for the `JobManagerOperatorMetricGroup`.
JobManagerProcessSpec	Describe the specifics of different resource dimensions of the JobManager process.
JobManagerProcessUtils	JobManager utils to calculate `JobManagerProcessSpec` and JVM args.
JobManagerProfilingFileHandler	Rest handler which serves the profiler result file from JobManager.
JobManagerProfilingFileHeaders	Headers for the `JobManagerProfilingFileHandler`.
JobManagerProfilingHandler	Rest handler which serves the profiling info from the JobManager.
JobManagerProfilingHeaders	Headers for the `JobManagerProfilingHandler`.
JobManagerProfilingListHandler	Rest handler which serves the profiling list from the JobManager.
JobManagerProfilingListHeaders	Headers for the `JobManagerProfilingHandler`.
JobManagerRegistration	Container for JobManager related registration information, such as the leader id or the job id.
JobManagerRunner	Interface for a runner which executes a `JobMaster`.
JobManagerRunnerFactory	Factory for a `JobManagerRunner`.
JobManagerRunnerRegistry	`JobManagerRunner` collects running jobs represented by `JobManagerRunner`.
JobManagerRunnerResult	The result of the `JobManagerRunner`.
JobManagerScopeFormat	The scope format for the `JobManagerMetricGroup`.
JobManagerSharedServices	Utility class which holds all auxiliary shared services used by the `JobMaster`.
JobManagerStdoutFileHeader	Headers for the `JobManagerStdoutFileHandler`.
JobManagerTaskRestore	This class encapsulates the data from the job manager to restore a task.
JobManagerThreadDumpHandler	Rest handler which serves the thread dump info from the JobManager.
JobManagerThreadDumpHeaders	Headers for the `JobManagerThreadDumpHandler`.
JobMaster	JobMaster implementation.
JobMasterConfiguration	Configuration for the `JobMaster`.
JobMasterException	Base class for `JobMaster` related exceptions.
JobMasterGateway	`JobMaster` rpc gateway interface.
JobMasterId	The `JobMaster` fencing token.
JobMasterOperatorEventGateway	Gateway to send an `OperatorEvent` or `CoordinationRequest` from the Task Manager to to the `OperatorCoordinator` on the JobManager side.
JobMasterPartitionTracker	Utility for tracking partitions and issuing release calls to task executors and shuffle masters.
JobMasterPartitionTrackerImpl	Utility for tracking partitions and issuing release calls to task executors and shuffle masters.
JobMasterRegistrationSuccess	Base class for responses from the ResourceManager to a registration attempt by a JobMaster.
JobMasterService	Interface which specifies the JobMaster service.
JobMasterServiceFactory	Factory for the `JobMasterService`.
JobMasterServiceLeadershipRunner	Leadership runner for the `JobMasterServiceProcess`.
JobMasterServiceLeadershipRunnerFactory	Factory which creates a `JobMasterServiceLeadershipRunner`.
JobMasterServiceProcess	JobMasterServiceProcess is responsible for running a `JobMasterService`.
JobMasterServiceProcess.WaitingForLeadership
JobMasterServiceProcessFactory	Factory for the `JobMasterServiceProcess`.
JobMessageParameters	Message parameters which require a job path parameter.
JobMetricGroup<C extends ComponentMetricGroup<C>>	Special abstract `MetricGroup` representing everything belonging to a specific job.
JobMetricsHandler	Request handler that returns for a given job a list of all available metrics or the values for a set of metrics.
JobMetricsHeaders	`MessageHeaders` for `JobMetricsHandler`.
JobMetricsMessageParameters	`MessageParameters` for `JobMetricsHandler`.
JobNotFinishedException	Exception indicating that a Flink job has not been finished.
JobPermanentBlobService	`PermanentBlobService` extension that gives access to register and release job artifacts.
JobPersistenceComponentFactory	Factory for components that are responsible for persisting a job for recovery.
JobPlanHandler	Handler serving the job execution plan.
JobPlanHeaders	Message headers for the `JobPlanHandler`.
JobPlanInfo	Response type of the `JobPlanHandler`.
JobPlanInfo.RawJson	Simple wrapper around a raw JSON string.
JobPlanInfo.RawJson.Deserializer	Json deserializer for the `JobPlanInfo.RawJson`.
JobPlanInfo.RawJson.Serializer	Json serializer for the `JobPlanInfo.RawJson`.
JobResourceRequirements	Information about the parallelism of job vertices.
JobResourceRequirements.Builder
JobResourceRequirementsBody	Body for change job requests.
JobResourceRequirementsHandler	Rest handler for reading current `resource requirements` of a given job.
JobResourceRequirementsHeaders	Headers for REST request to get details on job's resources.
JobResourceRequirementsUpdateHandler	Rest handler for updating `resource requirements` of a given job.
JobResourcesRequirementsUpdateHeaders	Headers for REST request to patch a job.
JobRestEndpointFactory	`RestEndpointFactory` which creates a `MiniDispatcherRestEndpoint`.
JobResult	Similar to `JobExecutionResult` but with an optional `SerializedThrowable` when the job failed.
JobResult.Builder	Builder for `JobResult`.
JobResultDeserializer	JSON deserializer for `JobResult`.
JobResultEntry	`JobResultEntry` is the entity managed by the `JobResultStore`.
JobResultSerializer	JSON serializer for `JobResult`.
JobResultStore	A storage for the results of globally terminated jobs.
JobResultStoreOptions	The set of configuration options relating to the Job Result Store.
JobSchedulingPlan	A plan that describes how to execute `JobGraph`.
JobSchedulingPlan.SlotAssignment	Assignment of a slot to some target (e.g. a slot sharing group).
JobsFilterQueryParameter	`MessageQueryParameter` for selecting jobs when aggregating metrics.
JobShuffleContext	Job level shuffle context which can offer some job information like job ID and through it, the shuffle plugin notify the job to stop tracking the lost result partitions.
JobShuffleContextImpl	The default implementation of `JobShuffleContext`.
JobsOverview	An overview of how many jobs are in which status.
JobsOverviewHandler	Overview handler for jobs.
JobsOverviewHeaders	Message headers for `JobsOverviewHandler`.
JobStatusHandler	Handler for requesting job status.
JobStatusInfo	The status of a specific job.
JobStatusInfoHeaders	`MessageHeaders` for `JobStatusHandler`.
JobStatusListener	Interface for observers that monitor the status of a job.
JobStatusMessage	A simple message that holds the state of a job execution.
JobStatusMetrics	Metrics that capture the time that a job spends in each `JobStatus`.
JobStatusProvider	Interface for querying the state of a job and the timestamps of state transitions.
JobStatusStore	Listens for and exposes the current job state and state timestamps.
JobSubmissionException	This exception denotes an error while submitting a job to the JobManager.
JobSubmitHandler	This handler can be used to submit jobs to a Flink cluster.
JobSubmitHeaders	These headers define the protocol for submitting a job to a flink cluster.
JobSubmitRequestBody	Request for submitting a job.
JobSubmitRequestBody.DistributedCacheFile	Descriptor for a distributed cache file.
JobSubmitResponseBody	Response to the submission of a job, containing a URL from which the status of the job can be retrieved from.
JobTable	A `JobTable's` task is to manage the lifecycle of a job on the `TaskExecutor`.
JobTable.Connection	A connection contains services bound to the lifetime of a connection with a JobManager.
JobTable.Job	A job contains services which are bound to the lifetime of a Flink job.
JobTable.JobServices	Services associated with a job.
JobTaskManagerMessageParameters	Message parameters which require a job path parameter and a TaskManager id path parameter.
JobType	Enum to distinguish JobGraphs between batch and streaming, currently used by the scheduler.
JobVertex	The base class for job vertexes.
JobVertex.FinalizeOnMasterContext	The context exposes some runtime infos for finalization.
JobVertex.InitializeOnMasterContext
JobVertexAccumulatorsHandler	Request handler for the job vertex accumulators.
JobVertexAccumulatorsHeaders	Message headers for the `JobVertexAccumulatorsHandler`.
JobVertexAccumulatorsInfo	Response type of the `JobVertexAccumulatorsHandler`.
JobVertexBackPressureHandler	Request handler for the job vertex back pressure.
JobVertexBackPressureHeaders	Message headers for the `JobVertexBackPressureHandler`.
JobVertexBackPressureInfo	Response type of the `JobVertexBackPressureHandler`.
JobVertexBackPressureInfo.SubtaskBackPressureInfo	Nested class to encapsulate the sub tasks back pressure.
JobVertexBackPressureInfo.VertexBackPressureLevel	Level of vertex back-pressure.
JobVertexBackPressureInfo.VertexBackPressureStatus	Status of vertex back-pressure.
JobVertexBuildContext	Helper class encapsulates all necessary information and configurations required during the construction of job vertices.
JobVertexDetailsHandler	Request handler for the job vertex details.
JobVertexDetailsHeaders	Message headers for the `JobVertexDetailsHandler`.
JobVertexDetailsInfo	Response type of the `JobVertexDetailsHandler`.
JobVertexFlameGraphHandler	Request handler for the job vertex Flame Graph.
JobVertexFlameGraphHeaders	Message headers for the `JobVertexFlameGraphHandler`.
JobVertexFlameGraphParameters	Message parameters for job vertex Flame Graph REST handler.
JobVertexForwardGroup	Job vertex level implement for `ForwardGroup`.
JobVertexID	A class for statistically unique job vertex IDs.
JobVertexIDDeserializer	Jackson deserializer for `JobVertexID`.
JobVertexIDKeyDeserializer	Jackson deserializer for `JobVertexID`.
JobVertexIDKeySerializer	Jackson serializer for `JobVertexID` used as a key serializer.
JobVertexIdPathParameter	Path parameter specifying a `JobVertexID`.
JobVertexIDSerializer	Jackson serializer for `JobVertexID`.
JobVertexInputInfo	This class describe how a job vertex consume an input(intermediate result).
JobVertexMessageParameters	Message parameters for job vertex REST handlers.
JobVertexMetricsHandler	Deprecated. This class is subsumed by `SubtaskMetricsHandler` and is only kept for backwards-compatibility.
JobVertexMetricsHeaders	`MessageHeaders` for `JobVertexMetricsHandler`.
JobVertexMetricsMessageParameters	`MessageParameters` for `JobVertexMetricsHandler`.
JobVertexResourceRequirements	Information about the parallelism of job vertices.
JobVertexResourceRequirements.Parallelism
JobVertexTaskManagersHandler	A request handler that provides the details of a job vertex, including id, name, and the runtime and metrics of all its subtasks aggregated by TaskManager.
JobVertexTaskManagersHeaders	Message headers for the `JobVertexTaskManagersHandler`.
JobVertexTaskManagersInfo	Response type of the `JobVertexTaskManagersHandler`.
JobVertexTaskManagersInfo.TaskManagersInfo	Detailed information about task managers.
JobVertexWatermarksHandler	Handler that returns the watermarks given a `JobID` and `JobVertexID`.
JobVertexWatermarksHeaders	`MessageHeaders` for retrieving watermarks.
JoinDriver<IT1,IT2,OT>	The join driver implements the logic of a join operator at runtime.
JoinedStreams<T1,T2>	`JoinedStreams` represents two `DataStreams` that have been joined.
JoinedStreams.WithWindow<T1,T2,KEY,W extends Window>	A join operation that has `KeySelectors` defined for both inputs as well as a `WindowAssigner`.
JoinTaskIterator<V1,V2,O>	Interface of an iterator that performs the logic of a match task.
JoinWithSolutionSetFirstDriver<IT1,IT2,OT>
JoinWithSolutionSetSecondDriver<IT1,IT2,OT>
JsonArchivist	Interface for all classes that want to participate in the archiving of job-related json responses.
JsonFactory	A holder for the singleton Jackson JSON factory.
JSONGenerator	Helper class for generating a JSON representation from a `StreamGraph`.
JsonPlanGenerator
JvmMetaspaceAndOverhead	JVM metaspace and overhead memory sizes.
JvmMetaspaceAndOverheadOptions	Options to calculate JVM Metaspace and Overhead.
JvmShutdownSafeguard	A utility that guards against blocking shutdown hooks that block JVM shutdown.
JvmUtils	Utilities for `ManagementFactory`.
KeepAliveWrite	Utilities to write.
KerberosLoginProvider	Provides Kerberos login functionality.
KerberosUtils	Provides vendor-specific Kerberos `AppConfigurationEntry` instances.
KeyAccountingUnit<K>	Key accounting unit holds the current in-flight key and tracks the corresponding ongoing records, which is used to preserve the ordering of independent chained `StateFuture`.
KeyContext	Interface for setting and querying the current key of keyed operations.
KeyContextHandler	This interface is used to optimize the calls of `Input.setKeyContextElement(org.apache.flink.streaming.runtime.streamrecord.StreamRecord<IN>)`, `StreamOperator.setKeyContextElement1(org.apache.flink.streaming.runtime.streamrecord.StreamRecord<?>)` and `StreamOperator.setKeyContextElement2(org.apache.flink.streaming.runtime.streamrecord.StreamRecord<?>)`.
Keyed<K>	Interface for objects that have a key attribute.
KeyedBackendSerializationProxy<K>	Serialization proxy for all meta data in keyed state backends.
KeyedBroadcastProcessFunction<KS,IN1,IN2,OUT>	A function to be applied to a `BroadcastConnectedStream` that connects `BroadcastStream`, i.e.
KeyedBroadcastStateTransformation<KEY,IN1,IN2,OUT>	A keyed `AbstractBroadcastStateTransformation`.
KeyedBroadcastStateTransformationTranslator<KEY,IN1,IN2,OUT>	A `TransformationTranslator` for the `KeyedBroadcastStateTransformation`.
KeyedCoProcessFunction<K,IN1,IN2,OUT>	A function that processes elements of two keyed streams and produces a single output one.
KeyedCoProcessOperator<K,IN1,IN2,OUT>	A `StreamOperator` for executing keyed `KeyedCoProcessFunction`.
KeyedMultipleInputTransformation<OUT>	`AbstractMultipleInputTransformation` implementation for keyed streams.
KeyedPartitionWindowedStream<T,KEY>	`KeyedPartitionWindowedStream` represents a data stream that collects all records with the same key separately into a full window.
KeyedProcessFunction<K,I,O>	A keyed function that processes elements of a stream.
KeyedProcessOperator<K,IN,OUT>	A `StreamOperator` for executing `KeyedProcessFunctions`.
KeyedSortPartitionOperator<INPUT,KEY>	The `KeyedSortPartitionOperator` sorts records of a partition on `KeyedStream`.
KeyedStateBackend<K>	A keyed state backend provides methods for managing keyed state.
KeyedStateBackend.KeySelectionListener<K>	Listener is given a callback when `KeyedStateBackend.setCurrentKey(K)` is called (key context changes).
KeyedStateBackendParametersImpl<K>	Internal POJO implementing `StateBackend.KeyedStateBackendParameters`
KeyedStateCheckpointOutputStream	Checkpoint output stream that allows to write raw keyed state in a partitioned way, split into key-groups.
KeyedStateFactory	This factory produces concrete internal state objects.
KeyedStateFunction<K,S extends org.apache.flink.api.common.state.State>	A function to be applied to all keyed states.
KeyedStateHandle	Base for the handles of the checkpointed states in keyed streams.
KeyedStream<T,KEY>	A `KeyedStream` represents a `DataStream` on which operator state is partitioned by key using a provided `KeySelector`.
KeyedStream.IntervalJoin<T1,T2,KEY>	Perform a join over a time interval.
KeyedStream.IntervalJoined<IN1,IN2,KEY>	IntervalJoined is a container for two streams that have keys for both sides as well as the time boundaries over which elements should be joined.
KeyExtractorFunction<T>	Function to extract a key from a given object.
KeyGroup	Part of a savepoint representing data for a single key group.
KeyGroupedInternalPriorityQueue<T>	This interface exists as (temporary) adapter between the new `InternalPriorityQueue` and the old way in which timers are written in a snapshot.
KeyGroupedIterator<E>
KeyGroupEntry	Part of a savepoint representing data for a single state entry in a key group.
KeyGroupPartitionedPriorityQueue<T,PQ extends InternalPriorityQueue<T> & HeapPriorityQueueElement>	This implementation of `InternalPriorityQueue` is internally partitioned into sub-queues per key-group and essentially works as a heap-of-heaps.
KeyGroupPartitionedPriorityQueue.PartitionQueueSetFactory<T,PQS extends InternalPriorityQueue<T> & HeapPriorityQueueElement>	Factory that produces the sub-queues that represent the partitions of a `KeyGroupPartitionedPriorityQueue`.
KeyGroupPartitioner<T>	Class that contains the base algorithm for partitioning data into key-groups.
KeyGroupPartitioner.ElementReaderFunction<T>	This functional interface defines how one element is read from a `DataInputView`.
KeyGroupPartitioner.ElementWriterFunction<T>	This functional interface defines how one element is written to a `DataOutputView`.
KeyGroupPartitioner.KeyGroupElementsConsumer<T>	Functional interface to consume elements from a key group.
KeyGroupPartitioner.PartitioningResult<T>	This represents the result of key-group partitioning.
KeyGroupRange	This class defines a range of key-group indexes.
KeyGroupRangeAssignment
KeyGroupRangeOffsets	This class combines a key-group range with offsets that correspond to the key-groups in the range.
KeyGroupsList	This interface offers ordered random read access to multiple key group ids.
KeyGroupsSavepointStateHandle	A `KeyGroupsStateHandle` that describes a savepoint in the unified format.
KeyGroupsStateHandle	A handle to the partitioned stream operator state after it has been checkpointed.
KeyGroupStatePartitionStreamProvider	This class provides access to an input stream that contains state data for one key group and the key group id.
KeyGroupStreamPartitioner<T,K>	Partitioner selects the target channel based on the key group index.
KeySelectorUtil	Utility class that contains helper methods to manipulating `KeySelector` for streaming.
KeySelectorUtil.ArrayKeySelector<IN>	A key selector for selecting individual array fields as keys and returns them as a Tuple.
KeySelectorUtil.ComparableKeySelector<IN>	A key selector for selecting key fields via a TypeComparator.
KeySelectorUtil.OneKeySelector<IN,K>	Key extractor that extracts a single field via a generic comparator.
KeyValueStateIterator	Iterator that over all key-value state entries in a `KeyedStateBackend`.
KvStateClientProxy	An interface for the Queryable State Client Proxy running on each Task Manager in the cluster.
KvStateEntry<K,N,V>	An entry holding the `InternalKvState` along with its `KvStateInfo`.
KvStateHandler	Handler for common queryable state logic.
KvStateInfo<K,N,V>	Metadata about a `InternalKvState`.
KvStateLocation	Location information for all key groups of a `InternalKvState` instance.
KvStateLocationOracle	Oracle for `KvStateLocation` in the cluster.
KvStateLocationRegistry	Simple registry, which maps `InternalKvState` registration notifications to `KvStateLocation` instances.
KvStateRegistry	A registry for `InternalKvState` instances per task manager.
KvStateRegistryGateway	Gateway to report key-value state registration and deregistrations.
KvStateRegistryListener	A listener for a `KvStateRegistry`.
KvStateServer	An interface for the Queryable State Server running on each Task Manager in the cluster.
KvStateService	KvState related components of each `TaskExecutor` instance.
LabeledGlobalFailureHandler	An interface for handling and associating global failures with labels from `FailureEnricher`.
LargeRecordHandler<T>
LastStateConnectionStateListener	`ConnectionStateListener` which records the last state it was notified about.
LatencyMarker	Special record type carrying a timestamp of its creation time at a source operator and the vertexId and subtask index of the operator.
LatencyStats	The `LatencyStats` objects are used to track and report on the behavior of latencies across measurements.
LatencyStats.Granularity	Granularity for latency metrics.
LatencyTrackingStateConfig	Config to create latency tracking state metric.
LatencyTrackingStateConfig.Builder
LatencyTrackingStateFactory<K,N,V,S extends org.apache.flink.api.common.state.State,IS extends InternalKvState<K,N,?>>	Factory to create `AbstractLatencyTrackState`.
LeaderContender	Interface which has to be implemented to take part in the leader election process of the `LeaderElectionService`.
LeaderElection	`LeaderElection` serves as a proxy between `LeaderElectionService` and `LeaderContender`.
LeaderElectionDriver	A leader election driver that allows to write `LeaderInformation` for multiple components.
LeaderElectionDriver.Listener	Listener interface for state changes of the `LeaderElectionDriver`.
LeaderElectionDriverFactory	Factory for `LeaderElectionDriver`.
LeaderElectionException	This exception is used in leader election-related scenarios.
LeaderElectionService	Interface for a service which allows to elect a leader among a group of contenders.
LeaderElectionUtils	`LeaderElectionUtils` collects helper methods to handle LeaderElection-related issues.
LeaderGatewayRetriever<T extends org.apache.flink.runtime.rpc.RpcGateway>	Retrieves and stores the leading `RpcGateway`.
LeaderInformation	Information about leader including the confirmed leader session id and leader address.
LeaderInformationRegister	A register containing the `LeaderInformation` for multiple contenders based on their `componentId`.
LeaderRetrievalDriver	A `LeaderRetrievalDriver` is responsible for retrieves the current leader which has been elected by the `LeaderElectionDriver`.
LeaderRetrievalDriverFactory	Factory for creating `LeaderRetrievalDriver` with different implementation.
LeaderRetrievalEventHandler	Interface which should be implemented to notify to `LeaderInformation` changes in `LeaderRetrievalDriver`.
LeaderRetrievalException	This exception is thrown by the `LeaderRetrievalUtils` when the method retrieveLeaderGateway fails to retrieve the current leader's gateway.
LeaderRetrievalHandler<T extends RestfulGateway>	`SimpleChannelInboundHandler` which encapsulates the leader retrieval logic for the REST endpoints.
LeaderRetrievalListener	Classes which want to be notified about a changing leader by the `LeaderRetrievalService` have to implement this interface.
LeaderRetrievalService	This interface has to be implemented by a service which retrieves the current leader and notifies a listener about it.
LeaderRetrievalUtils	Utility class to work with `LeaderRetrievalService` class.
LeaderRetrievalUtils.LeaderInformationListener	Helper class which is used by the retrieveLeaderInformation method to retrieve the leader's rpc URL and the current leader session ID.
LeaderRetriever	Retrieves and stores the current leader address.
LeadershipLostException	This exception is used in the scenario that the leadership is lost.
LeftOuterJoinDriver<IT1,IT2,OT>	The left outer join driver implements the logic of an outer join operator at runtime.
LegacyKeyedCoProcessOperator<K,IN1,IN2,OUT>	Deprecated. Replaced by `KeyedCoProcessOperator` which takes `KeyedCoProcessFunction`
LegacyKeyedProcessOperator<K,IN,OUT>	Deprecated. Replaced by `KeyedProcessOperator` which takes `KeyedProcessFunction`
LegacySinkTransformation<T>	This Transformation represents a stream Sink.
LegacySinkTransformationTranslator<IN>	A `TransformationTranslator` for the `LegacySinkTransformation`.
LegacySourceTransformation<T>	This represents a Source.
LegacySourceTransformationTranslator<OUT>	A `TransformationTranslator` for the `LegacySourceTransformation`.
LibraryCacheManager	The LibraryCacheManager is responsible for creating and managing the user code class loaders.
LibraryCacheManager.ClassLoaderHandle	Handle to retrieve a user code class loader for the associated job.
LibraryCacheManager.ClassLoaderLease	Lease which allows to signal when the user code class loader is no longer needed.
LineageDataset	Lineage dataset represents the source or sink in the job.
LineageDatasetFacet	Facet interface for dataset.
LineageEdge	Lineage edge from source to sink.
LineageGraph	Job lineage graph that users can get sources, sinks and relationships from lineage and manage the relationship between jobs and tables.
LineageGraphUtils	Utils for building lineage graph from transformations.
LineageVertex	Lineage vertex represents the connectors in lineage graph, including source `SourceLineageVertex` and sink.
LineageVertexProvider	Create lineage vertex for source and sink in DataStream.
ListCheckpointed<T extends Serializable>	Deprecated. If you need to do non-keyed state snapshots of your operator, use `CheckpointedFunction`.
ListDelimitedSerializer	Encapsulates a logic of serialization and deserialization of a list with a delimiter.
ListMemorySegmentSource	Simple memory segment source that draws segments from a list.
ListStateAdaptor<K,N,V>	An adaptor that transforms `InternalListState` into `InternalListState`.
LocalBufferPool	A buffer pool used to manage a number of `Buffer` instances from the `NetworkBufferPool`.
LocalChangelogRegistry	This registry is responsible for deleting changlog's local handles which are not in use.
LocalChangelogRegistryImpl
LocalConnectionManager	A connection manager implementation to bypass setup overhead for task managers running in local execution mode.
LocalInputChannel	An input channel, which requests a local subpartition.
Locality
LocallyCleanableResource	`LocallyCleanableResource` is supposed to be implemented by any class that provides artifacts for a given job that need to be cleaned up after the job reached a local terminal state.
LocalRecoveredInputChannel	An input channel reads recovered state from previous unaligned checkpoint snapshots and then converts into `LocalInputChannel` finally.
LocalRecoveryConfig	This class encapsulates the completed configuration for local recovery, i.e. the root directories into which all file-based snapshots can be written and the general mode for the local recover feature.
LocalSnapshotDirectoryProvider	Provides directories for local backup or local recovery.
LocalSnapshotDirectoryProviderImpl	Implementation of `LocalSnapshotDirectoryProvider`.
LocalStrategy	Enumeration of all available local processing strategies tasks.
LocalStreamEnvironment	The LocalStreamEnvironment is a StreamExecutionEnvironment that runs the program locally, multi-threaded, in the JVM where the environment is instantiated.
LocalTransportException
LocationPreferenceConstraint	Defines the location preference constraint.
LocationPreferenceSlotSelectionStrategy	This class implements a `SlotSelectionStrategy` that is based on location preference hints.
LogFileNamePathParameter	Parameters used by `TaskManagerCustomLogHandler` and `JobManagerCustomLogHandler`.
LogicalEdge	Represents an edge in `LogicalTopology`, i.e.
LogicalFile	An abstraction of logical files in file-merging checkpoints.
LogicalFile.LogicalFileId	ID for `LogicalFile`.
LogicalPipelinedRegion	Pipelined region on logical level, i.e., `JobVertex` level.
LogicalPipelinedRegionComputeUtil	Utils for computing `LogicalPipelinedRegion`s.
LogicalResult	Represents a data set produced by a `LogicalVertex`, i.e.
LogicalSlot	A logical slot represents a resource on a TaskManager into which a single task can be deployed.
LogicalSlot.Payload	Payload for a logical slot.
LogicalTopology	Represents a logical topology, i.e.
LogicalVertex	Represents a vertex in `LogicalTopology`, i.e.
LogInfo	Contains information about one log of TaskManager.
LogListInfo	Class containing a collection of `LogInfo`.
LogUrlResponse	Response of log URLs.
LongArrayList	Minimal implementation of an array-backed list of longs
LongWatermarkCombiner	A `WatermarkCombiner` for unaligned `LongWatermark`s.
LongWatermarkCombiner.LongWatermarkElement	This class implements `HeapPriorityQueue.HeapPriorityQueueElement` to help find the maximum/minimum `LongWatermark`.
Lz4BlockCompressionFactory	Implementation of `BlockCompressionFactory` for Lz4 codec.
Lz4BlockCompressor	Encode data into LZ4 format (not compatible with the LZ4 Frame format).
Lz4BlockDecompressor	Decode data written with `Lz4BlockCompressor`.
Mail	An executable bound to a specific operator in the chain, such that it can be picked for downstream mailbox.
MailboxDefaultAction	Interface for the default action that is repeatedly invoked in the mailbox-loop.
MailboxDefaultAction.Controller	This controller is a feedback interface for the default action to interact with the mailbox execution.
MailboxDefaultAction.Suspension	Represents the suspended state of a `MailboxDefaultAction`, ready to resume.
MailboxExecutorFactory	A factory for creating mailbox executors with a given priority.
MailboxExecutorImpl	Implementation of an executor service build around a mailbox-based execution model.
MailboxMetricsController	Mailbox metrics controller class.
MailboxProcessor	This class encapsulates the logic of the mailbox-based execution model.
MailboxProcessor.MailboxController	Implementation of `MailboxDefaultAction.Controller` that is connected to a `MailboxProcessor` instance.
MailboxWatermarkProcessor<OUT>	A helper class to let operators emit watermarks incrementally from mailbox.
ManagedInitializationContext	This interface provides a context in which operators can initialize by registering to managed state (i.e. state that is managed by state backends).
ManagedMemoryUtils	Utils for configuration and calculations related to managed memory and its various use cases.
ManagedSnapshotContext	This interface provides a context in which operators that use managed state (i.e. state that is managed by state backends) can perform a snapshot.
MapDriver<IT,OT>	Map task which is executed by a Task Manager.
MapPartitionDriver<IT,OT>	MapPartition task which is executed by a Task Manager.
MapPartitionIterator<IN>	The `MapPartitionIterator` is an iterator used in the `MapPartitionOperator`.The task main thread will add records to it.
MapPartitionOperator<IN,OUT>	The `MapPartitionOperator` is used to process all records in each partition on non-keyed stream.
MappingBasedRepartitioner<T>	A repartitioner that assigns the same channel state to multiple subtasks according to some mapping.
MapStateAdaptor<K,N,UK,UV>	An adaptor that transforms `InternalMapState` into `InternalMapState`.
MarkPartitionFinishedStrategy	This strategy is used to decide whether partition needs to be marked as finished.
MasterHooks	Collection of methods to deal with checkpoint master hooks.
MasterState	Simple encapsulation of state generated by checkpoint coordinator.
MasterTriggerRestoreHook<T>	The interface for hooks that can be called by the checkpoint coordinator when triggering or restoring a checkpoint.
MasterTriggerRestoreHook.Factory	A factory to instantiate a `MasterTriggerRestoreHook`.
MaterializationExpiredException	Indicates that the `BroadcastVariableMaterialization` has materialized the broadcast variable at some point but discarded it already.
MemCheckpointStreamFactory	`CheckpointStreamFactory` that produces streams that write to in-memory byte arrays.
MemCheckpointStreamFactory.MemoryCheckpointOutputStream	A `CheckpointStateOutputStream` that writes into a byte array.
MemoryAllocationException	An exception to be thrown when a memory allocation operation is not successful.
MemoryBackendCheckpointStorageAccess	An implementation of a checkpoint storage for the `JobManagerCheckpointStorage`.
MemoryBlockIterator	The memory block iterator is an iterator that always buffers a block of elements in memory.
MemoryExecutionGraphInfoStore	`ExecutionGraphInfoStore` implementation which stores the `ArchivedExecutionGraph` in memory.
MemoryLogger	A thread the periodically logs statistics about: Heap and non-heap memory usage Memory pools and pool usage Garbage collection times and counts
MemoryManager	The memory manager governs the memory that Flink uses for sorting, hashing, caching or off-heap state backends (e.g.
MemoryReservationException	An exception to be thrown when a memory reservation operation is not successful.
MemoryTierConsumerAgent	The data client is used to fetch data from memory tier.
MemoryTierFactory	The implementation of `TierFactory` for memory tier.
MemoryTierProducerAgent	The memory tier implementation of `TierProducerAgent`.
MergeIterator<E>	An iterator that returns a sorted merge of the sequences of elements from a set of iterators, assuming those sequences are ordered themselves.
MergingStateAdaptor<K,N,IN,ACC,OUT,SYNCOUT>	An adaptor that transforms `InternalMergingState` into `InternalMergingState`.
MergingWindowAssigner<T,W extends Window>	A `WindowAssigner` that can merge windows.
MergingWindowAssigner.MergeCallback<W>	Callback to be used in `MergingWindowAssigner.mergeWindows(Collection, MergeCallback)` for specifying which windows should be merged.
MergingWindowSet<W extends Window>	Utility for keeping track of merging `Windows` when using a `MergingWindowAssigner` in a `WindowOperator`.
MergingWindowSet.MergeFunction<W>	Callback for `MergingWindowSet.addWindow(Window, MergeFunction)`.
MessageHeaders<R extends RequestBody,P extends ResponseBody,M extends MessageParameters>	This class links `RequestBody`s to `ResponseBody`s types and contains meta-data required for their http headers.
MessageParameter<X>	This class represents a single path/query parameter that can be used for a request.
MessageParameter.MessageParameterRequisiteness	Enum for indicating whether a parameter is mandatory or optional.
MessageParameters	This class defines the path/query `MessageParameter`s that can be used for a request.
MessagePathParameter<X>	This class represents path parameters of a request.
MessageQueryParameter<X>	This class represents query parameters of a request.
MetadataOutputStreamWrapper	The wrapper manages metadata output stream close and commit.
MetadataSerializer	Deserializer for checkpoint metadata.
MetadataSerializers	Helper to access `MetadataSerializer`s for specific format versions.
MetadataV1Serializer	Deserializer for checkpoints written in format `1` (Flink 1.2.x format).
MetadataV2Serializer	(De)serializer for checkpoint metadata format version 2.
MetadataV2V3SerializerBase	Base (De)serializer for checkpoint metadata format version 2 and 3.
MetadataV2V3SerializerBase.DeserializationContext	A context that keeps information needed during serialization.
MetadataV3Serializer	(De)serializer for checkpoint metadata format version 3.
MetadataV4Serializer	V4 serializer that adds `CheckpointProperties` serialization.
MetadataV5Serializer	V5 serializer that adds Operator name and uid.
Metric	Response type for a Metric and Metric-Value-Pair.
MetricCollectionResponseBody	Response type for a collection of metrics.
MetricCollectionResponseBody.Deserializer	JSON deserializer for `MetricCollectionResponseBody`.
MetricCollectionResponseBody.Serializer	JSON serializer for `MetricCollectionResponseBody`.
MetricDump	A container for a dumped metric that contains the scope, name and value(s) of the metric.
MetricDump.CounterDump	Container for the value of a `Counter`.
MetricDump.GaugeDump	Container for the value of a `Gauge` as a string.
MetricDump.HistogramDump	Container for the values of a `Histogram`.
MetricDump.MeterDump	Container for the rate of a `Meter`.
MetricDumpSerialization	Utility class for the serialization of metrics.
MetricDumpSerialization.MetricDumpDeserializer	Deserializer for reading a list of `MetricDumps` from a `MetricDumpSerialization.MetricSerializationResult`.
MetricDumpSerialization.MetricDumpSerializer	Serializes a set of metrics into a `MetricDumpSerialization.MetricSerializationResult`.
MetricDumpSerialization.MetricSerializationResult	This class encapsulates all serialized metrics and a count for each metric type.
MetricFetcher	The MetricFetcher can be used to fetch metrics from the JobManager and all registered TaskManagers.
MetricFetcherImpl<T extends RestfulGateway>	Implementation of `MetricFetcher` which fetches metrics from the `MetricQueryServiceGateway`.
MetricFilter	A filter for metrics.
MetricNames	Collection of metric names.
MetricQueryService	The MetricQueryService creates a key-value representation of all metrics currently registered with Flink when queried.
MetricQueryServiceGateway	`MetricQueryService` rpc gateway interface.
MetricQueryServiceRetriever	Retriever for `MetricQueryServiceGateway`.
MetricRegistry	Interface for a metric registry.
MetricRegistryConfiguration	Configuration object for `MetricRegistryImpl`.
MetricRegistryImpl	A MetricRegistry keeps track of all registered `Metrics`.
MetricsAggregationParameter	TODO: add javadoc.
MetricsAggregationParameter.AggregationMode	The available aggregations.
MetricsFilterParameter	`MessageQueryParameter` for filtering metrics provided by `MetricStore`.
MetricsRegistrar	A component that can register metrics.
MetricStore	Nested data-structure to store metrics.
MetricStore.ComponentMetricStore	Structure containing metrics of a single component.
MetricStore.SubtaskMetricStore	Sub-structure containing metrics of a single subtask.
MetricStore.TaskManagerMetricStore	Sub-structure containing metrics of a single TaskManager.
MetricStore.TaskMetricStore	Sub-structure containing metrics of a single Task.
MetricUtils	Utility class to register pre-defined metric sets.
MimeTypes	Simple utility class that resolves file extensions to MIME types.
MiniCluster	MiniCluster to execute Flink jobs locally.
MiniCluster.CommonRpcServiceFactory	Factory which returns always the common `RpcService`.
MiniCluster.HaServices	HA Services to use.
MiniCluster.RpcServiceFactory	Internal factory for `RpcService`.
MiniClusterConfiguration	Configuration object for the `MiniCluster`.
MiniClusterConfiguration.Builder	Builder for the MiniClusterConfiguration.
MiniClusterJobClient	A `JobClient` for a `MiniCluster`.
MiniClusterJobClient.JobFinalizationBehavior	Determines the behavior of the `MiniClusterJobClient` when the job finishes.
MiniDispatcherRestEndpoint	REST endpoint for the ApplicationClusterEntryPoint.
MinWatermarkGauge	A `Gauge` for exposing the minimum watermark of chosen `WatermarkGauge`s.
ModifiableClusterConfiguration	Configuration class which contains the parsed command line arguments for the `ClusterEntrypoint`.
ModifiableClusterConfigurationParserFactory	A class can be used to extract the configuration from command line and modify it.
MultiInputSortingDataInput<IN,K>	An input that wraps an underlying input and sorts the incoming records.
MultiInputSortingDataInput.SelectableSortingInputs	A wrapper that combines sorting `inputs` with a `InputSelectable` that should be used to choose which input to consume next from.
MultiInputTransformationTranslator<OUT>	A `TransformationTranslator` for the `MultipleInputTransformation` and the `KeyedMultipleInputTransformation`.
MultipartRoutes	A utility for `FileUploadHandler` to determine whether it should accept a request.
MultipartRoutes.Builder
MultipleFuturesAvailabilityHelper	This class is semi-thread safe.
MultipleInputSelectionHandler	This handler is mainly used for selecting the next available input index in `StreamMultipleInputProcessor`.
MultipleInputStreamOperator<OUT>	Interface for stream operators with multiple `Input`s.
MultipleInputStreamTask<OUT>	A `StreamTask` for executing a `MultipleInputStreamOperator` and supporting the `MultipleInputStreamOperator` to select input for reading.
MultipleInputTransformation<OUT>	`AbstractMultipleInputTransformation` implementation for non-keyed streams.
MultipleJobsDetails	An actor messages describing details of various jobs.
MultipleRecordWriters<T extends org.apache.flink.core.io.IOReadableWritable>	The specific delegate implementation for the multiple outputs case.
MutableHashTable<BT,PT>	An implementation of a Hybrid Hash Join.
MutableHashTable.HashBucketIterator<BT,PT>
MutableHashTable.ProbeIterator<PT>
MutableHashTable.UnmatchedBuildIterator<BT,PT>	Iterate all the elements in memory which has not been probed during probe phase.
MutableIOMetrics	This class is a mutable version of the `IOMetrics` class that allows adding up IO-related metrics.
MutableReader<T extends org.apache.flink.core.io.IOReadableWritable>	A record-oriented reader for mutable record types.
MutableRecordReader<T extends org.apache.flink.core.io.IOReadableWritable>	Implementation of the record-oriented reader for mutable record types.
MutableVertexAttemptNumberStore	Mutability extension to the `VertexAttemptNumberStore`.
MutableVertexParallelismStore	Mutability extension to the `VertexParallelismStore`.
NamedBiFunction<T,U,V>	A named version of `BiFunction`.
NamedCallback	A named callback that can be identified and checkpoint.
NamedConsumer<T>	A named version of `Consumer`.
NamedFunction<T,R>	A named version of `Function`.
NettyBufferPool	Extends around Netty's `PooledByteBufAllocator` with strict control over the number of created arenas.
NettyConfig
NettyConnectionId	`NettyConnectionId` indicates the unique id of netty connection.
NettyConnectionManager
NettyConnectionReader	`NettyConnectionReader` is used by `TierConsumerAgent` to read buffer from netty.
NettyConnectionReaderImpl	The default implementation of `NettyConnectionReader`.
NettyConnectionWriter	`NettyConnectionWriter` is used by `TierProducerAgent` to write buffers to netty connection.
NettyConnectionWriterImpl	The default implementation of `NettyConnectionWriter`.
NettyMessage	A simple and generic interface to serialize messages to Netty's buffer space.
NettyMessageClientDecoderDelegate	Decodes messages from the received netty buffers.
NettyPartitionRequestClient	Partition request client for remote partition requests.
NettyPartitionRequestListener	Implementation of `PartitionRequestListener` for netty partition request.
NettyPayload	The `NettyPayload` represents the payload that will be transferred to netty connection.
NettyPayloadManager	`NettyPayloadManager` is used to contain all netty payloads from a storage tier.
NettyProtocol	Defines the server and client channel handlers, i.e. the protocol, used by netty.
NettyServiceProducer	`NettyServiceProducer` is used as the callback to register `NettyConnectionWriter` and disconnect netty connection in `TierProducerAgent`.
NettyShuffleDescriptor	Default implementation of `ShuffleDescriptor` for `NettyShuffleMaster`.
NettyShuffleDescriptor.LocalExecutionPartitionConnectionInfo	Local partition connection information.
NettyShuffleDescriptor.NetworkPartitionConnectionInfo	Remote partition connection information with index to query partition.
NettyShuffleDescriptor.PartitionConnectionInfo	Information for connection to partition producer for shuffle exchange.
NettyShuffleEnvironment	The implementation of `ShuffleEnvironment` based on netty network communication, local memory and disk files.
NettyShuffleEnvironmentConfiguration	Configuration object for the network stack.
NettyShuffleMaster	Default `ShuffleMaster` for netty and local file based shuffle implementation.
NettyShuffleMetricFactory	Factory for netty shuffle service metrics.
NettyShuffleServiceFactory	Netty based shuffle service implementation.
NettyShuffleUtils	Utils to calculate network memory requirement of a vertex from network configuration and details of input and output.
NetworkActionsLogger	Utility class for logging actions that happened in the network stack for debugging purposes.
NetworkBuffer	Wrapper for pooled `MemorySegment` instances.
NetworkBufferPool	The NetworkBufferPool is a fixed size pool of `MemorySegment` instances for the network stack.
NetworkClientHandler	Channel handler to read and write network messages on client side.
NetworkSequenceViewReader	Simple wrapper for the partition readerQueue iterator, which increments a sequence number for each returned buffer and remembers the receiver ID.
NoMatchSecurityFactoryException	Exception for not finding suitable security factories.
NoMoreSplitsEvent	A source event sent from the SplitEnumerator to the SourceReader to indicate that no more splits will be assigned to the source reader anymore.
NonAdaptiveExecutionHandler	A `NonAdaptiveExecutionHandler` implements the `AdaptiveExecutionHandler` interface to provide an immutable static job graph.
NonAdaptiveExecutionPlanSchedulingContext	The `NonAdaptiveExecutionPlanSchedulingContext` is a final class that implements a scheduling context for execution plans that do not require adaptive changes.
NonBlockingPhysicalFilePool	A Non-Blocking `PhysicalFilePool` which will always provide usable physical file without blocking.
NonChainedOutput	Used by operator chain and represents a non-chained output of the corresponding stream operator.
NonClosingCheckpointOutputStream<T extends StreamStateHandle>	Abstract class to implement custom checkpoint output streams which should not be closable for user code.
NonClosingInputStreamDecorator	Decorator for input streams that ignores calls to `InputStream.close()`.
NonClosingOutputStreamDecorator	Decorator for input streams that ignores calls to `OutputStream.close()`.
NonKeyedPartitionWindowedStream<T>	`NonKeyedPartitionWindowedStream` represents a data stream that collects all records of each subtask separately into a full window.
NonLeaderRetrievalRestfulGateway	* Gateway for restful endpoints without leader retrieval logic. * *
NonPersistentMetadataCheckpointStorageLocation	A checkpoint storage location for the `MemCheckpointStreamFactory` in case no durable persistence for metadata has been configured.
NonRecordWriter<T extends org.apache.flink.core.io.IOReadableWritable>	The specific delegate implementation for the non output case like sink task.
NonReusingBlockResettableIterator<T>	Implementation of an iterator that fetches a block of data into main memory and offers resettable access to the data in that block.
NonReusingBuildFirstHashJoinIterator<V1,V2,O>	An implementation of the `JoinTaskIterator` that uses a hybrid-hash-join internally to match the records with equal key.
NonReusingBuildFirstReOpenableHashJoinIterator<V1,V2,O>
NonReusingBuildSecondHashJoinIterator<V1,V2,O>	An implementation of the `JoinTaskIterator` that uses a hybrid-hash-join internally to match the records with equal key.
NonReusingBuildSecondReOpenableHashJoinIterator<V1,V2,O>
NonReusingDeserializationDelegate<T>	A `DeserializationDelegate` that always creates a new instance upon deserialization.
NonReusingKeyGroupedIterator<E>	The key grouped iterator returns a key and all values that share the same key.
NonReusingMergeInnerJoinIterator<T1,T2,O>
NonReusingMergeOuterJoinIterator<T1,T2,O>
NonReusingMutableToRegularIteratorWrapper<T>	This class wraps a `MutableObjectIterator` into a regular `Iterator`.
NonReusingSortMergeCoGroupIterator<T1,T2>
NonSupportedResourceAllocatorImpl	ResourceAllocator that not support to allocate/release resources.
NoOpBlocklistHandler	No-op implementation of `BlocklistHandler`.
NoOpBlocklistHandler.Factory	The factory to instantiate `NoOpBlocklistHandler`.
NoOpChainedDriver<IT>	A chained driver that just passes on the input as the output
NoOpCheckpointStatsTracker
NoOpDeclareResourceRequirementServiceConnectionManager	No-op implementation of the `DeclareResourceRequirementServiceConnectionManager`.
NoOpDelegationTokenManager	`DelegationTokenManager` implementation which does nothing.
NoOpDispatcherBootstrap	A `DispatcherBootstrap` which submits the provided `job graphs` for execution upon dispatcher initialization.
NoOpDriver<T>	A driver that does nothing but forward data from its input to its output.
NoOpExecutionDeploymentListener	No-op implementation of `ExecutionDeploymentListener`.
NoOpExecutionPlanStoreWatcher	Singleton `ExecutionPlanStoreWatcher` empty implementation.
NoOpHeartbeatManager<I,O>	`HeartbeatManager` implementation which does nothing.
NoOpHeartbeatServices	`HeartbeatServices` implementation which does nothing.
NoOpMasterAgent	The empty implementation for `TierMasterAgent`.
NoOpMetricRegistry	Metric registry which does nothing.
NoOpResultSubpartitionView	A dummy implementation of the `ResultSubpartitionView`.
NoOpSecurityContext	A security context that simply runs a Callable without performing a login action.
NoOpSecurityContextFactory	Default security context factory for `NoOpSecurityContext`.
NoOpSlotAllocationSnapshotPersistenceService	`SlotAllocationSnapshotPersistenceService` that does nothing.
NoOpTaskActions	A dummy implementation of the `TaskActions` which is mainly used for tests.
NoOpTaskLocalStateStoreImpl	This class implements a `TaskLocalStateStore` with no functionality and is used when local recovery is disabled.
NoOpTierShuffleDescriptor	The empty implementation for `TierShuffleDescriptor`.
NoOpTimestampsAndWatermarks<T>	An implementation of `TimestampsAndWatermarks` where all watermarking/event-time operations are no-ops.
NoResourceAvailableException	Indicates resource allocation failures.
NoRestartBackoffTimeStrategy	Restart strategy which does not restart tasks when tasks fail.
NoRestartBackoffTimeStrategy.NoRestartBackoffTimeStrategyFactory	The factory for creating `NoRestartBackoffTimeStrategy`.
NormalizedKeySorter<T>
NotDuplicatingCheckpointStateToolset	An empty implementation of `CheckpointStateToolset`.
NotFoundException	A special exception that indicates that an element was not found and that the request should be answered with a `404` return code.
NotificationListener
NotReleasingPartitionGroupReleaseStrategy	Does not release intermediate result partitions during job execution.
NotReleasingPartitionGroupReleaseStrategy.Factory	Factory for `NotReleasingPartitionGroupReleaseStrategy`.
OnCompletionActions	Interface for completion actions once a Flink job has reached a terminal state.
OneInputStreamOperator<IN,OUT>	Interface for stream operators with one input.
OneInputStreamOperatorFactory<IN,OUT>	A factory to create `OneInputStreamOperator`.
OneInputStreamTask<IN,OUT>	A `StreamTask` for executing a `OneInputStreamOperator`.
OneInputTransformation<IN,OUT>	This Transformation represents the application of a `OneInputStreamOperator` to one input `Transformation`.
OneInputTransformationTranslator<IN,OUT>	A `TransformationTranslator` for the `OneInputTransformation`.
OnlyExecutionGraphJsonArchivist	Interface for all classes that want to participate in the archiving of job-related json responses but only provide `AccessExecutionGraph`-related information.
OnMainThreadJobManagerRunnerRegistry	`OnMainThreadJobManagerRunnerRegistry` implements `JobManagerRunnerRegistry` guarding the passed `JobManagerRunnerRegistry` instance in a way that it only allows modifying methods to be executed on the component's main thread.
OpaqueMemoryResource<T>	An opaque memory resource, meaning a memory resource not understood by Flink or the JVM.
OperationAlreadyFailedException	Exception indicating that a requested operation already exists and has failed.
OperationKey	Any operation key for the `AbstractAsynchronousOperationHandlers` must extend this class.
OperationResult<R>	Encapsulates the result of an asynchronous operation.
OperationResultStatus	Current status of an asynchronous operation.
OperatorAttributes	OperatorAttributes element provides Job Manager with information that can be used to optimize job performance.
OperatorAttributesBuilder	The builder class for `OperatorAttributes`.
OperatorBackendSerializationProxy	Serialization proxy for all meta data in operator state backends.
OperatorChain<OUT,OP extends StreamOperator<OUT>>	The `OperatorChain` contains all operators that are executed as one chain within a single `StreamTask`.
OperatorChain.ChainedSource	Wrapper class to access the chained sources and their's outputs.
OperatorChainInfo	Helper class to help maintain the information of an operator chain.
OperatorCoordinator	A coordinator for runtime operators.
OperatorCoordinator.Context	The context gives the OperatorCoordinator access to contextual information and provides a gateway to interact with other components, such as sending operator events.
OperatorCoordinator.Provider	The provider creates an OperatorCoordinator and takes a `OperatorCoordinator.Context` to pass to the OperatorCoordinator.
OperatorCoordinator.SubtaskGateway	The `SubtaskGateway` is the way to interact with a specific parallel instance of the Operator (an Operator subtask), like sending events to the operator.
OperatorCoordinatorCheckpointContext	This context is the interface through which the `CheckpointCoordinator` interacts with an `OperatorCoordinator` during checkpointing and checkpoint restoring.
OperatorCoordinatorHandler	Handler for the `OperatorCoordinators`.
OperatorCoordinatorHolder	The `OperatorCoordinatorHolder` holds the `OperatorCoordinator` and manages all its interactions with the remaining components.
OperatorEvent	Root interface for all events sent between `OperatorCoordinator` and an `OperatorEventHandler`.
OperatorEventDispatcher	The dispatcher through which Operators receive `OperatorEvent`s and through which they can send OperatorEvents back to the `OperatorCoordinator`.
OperatorEventDispatcherImpl	An implementation of the `OperatorEventDispatcher`.
OperatorEventGateway	The gateway through which an Operator can send an `OperatorEvent` to the `OperatorCoordinator` on the JobManager side.
OperatorEventHandler	Interface for handlers of operator events on the operator side.
OperatorID	A class for statistically unique operator IDs.
OperatorIDPair	Formed of a mandatory operator ID and optionally a user defined operator ID.
OperatorInfo	An interface to access basic properties of an operator in the context of its coordinator.
OperatorInfo	Helper class to help maintain the information of an operator.
OperatorInstanceID	An ID for physical instance of the operator.
OperatorListStateAdaptor<V>	An adaptor that transforms `InternalListState` into `InternalListState`.
OperatorScopeFormat	The scope format for the `InternalOperatorMetricGroup`.
OperatorsFinished	This class represents the information about the finished operators.
OperatorSnapshotFinalizer	This class finalizes `OperatorSnapshotFutures`.
OperatorSnapshotFutures	Result of `StreamOperator.snapshotState(long, long, org.apache.flink.runtime.checkpoint.CheckpointOptions, org.apache.flink.runtime.state.CheckpointStreamFactory)`.
OperatorState	Simple container class which contains the raw/managed operator state and key-group state handles from all subtasks of an operator and therefore represents the complete state of a logical operator.
OperatorStateBackend	Interface that combines both, the user facing `OperatorStateStore` interface and the system interface `Snapshotable`.
OperatorStateBackendParametersImpl	Internal POJO implementing `StateBackend.OperatorStateBackendParameters`
OperatorStateCheckpointOutputStream	Checkpoint output stream that allows to write raw operator state in a partitioned way.
OperatorStateHandle	Interface of a state handle for operator state.
OperatorStateHandle.Mode	The modes that determine how an `OperatorStreamStateHandle` is assigned to tasks during restore.
OperatorStateHandle.StateMetaInfo	Meta information about the operator state handle.
OperatorStateRepartitioner<T>	Interface that allows to implement different strategies for repartitioning of operator state as parallelism changes.
OperatorStateRestoreOperation	Implementation of operator state restore operation.
OperatorStreamStateHandle	State handle for partitionable operator state.
OperatorSubtaskDescriptionText	This class generates a string that can be used to identify an operator subtask.
OperatorSubtaskState	This class encapsulates the state for one parallel instance of an operator.
OperatorSubtaskState.Builder	The builder for a new `OperatorSubtaskState` which can be obtained by `OperatorSubtaskState.builder()`.
OperatorUidPathParameter	Path parameter identifying operators.
OutboundChannelHandlerFactory	Custom netty outbound handler factory in order to make custom changes on netty outbound data.
Output<T>	A `StreamOperator` is supplied with an object of this interface that can be used to emit elements and other messages, such as barriers and watermarks, from an operator.
OutputBufferPoolUsageGauge	Gauge metric measuring the output buffer pool usage gauge for `ResultPartition`s.
OutputBuffersGauge	Gauge metric measuring the number of queued output buffers for `ResultPartition`s.
OutputBuffersSizeGauge	Gauge metric measuring the size in bytes of queued output buffers for `ResultPartition`s.
OutputCollector<T>	The OutputCollector collects records, and emits them to the `RecordWriter`s.
OutputEmitter<T>	The output emitter decides to which of the possibly multiple output channels a record is sent.
OutputFormatOperatorFactory<IN,OUT>	Interface for operator factories which create the sink operator containing an `OutputFormat`.
OutputFormatSinkFunction<IN>	Deprecated. Please use the `StreamingFileSink` for writing to files from a streaming program.
OutputWithChainingCheck<OUT>	This is a wrapper for outputs to check whether the collected record has been emitted to a downstream subtask or to a chained operator.
OwnedTaskLocalStateStore	This interface represents the administrative interface to `TaskLocalStateStore`, that only the owner of the object should see.
PageSizeUtil	Utility for accessing the system page size.
ParallelismAndInputInfos	The parallelism and `JobVertexInputInfo`s of a job vertex .
ParallelSourceFunction<OUT>	Deprecated. This interface is based on the `SourceFunction` API, which is due to be removed.
ParserResultFactory<T>	Parser result factory used by the `CommandLineParser`.
PartialDispatcherServices	Partial `DispatcherServices` services container which needs to be completed before being given to the `Dispatcher`.
PartialDispatcherServicesWithJobPersistenceComponents	`DispatcherFactory` services container.
PartialFinishedInputConsumableDecider	`PartialFinishedInputConsumableDecider` is a special `InputConsumableDecider`.
PartialFinishedInputConsumableDecider.Factory	Factory for `PartialFinishedInputConsumableDecider`.
PartialOrderPriorityQueue<T>	This class implements a priority-queue, which maintains a partial ordering of its elements such that the least element can always be found in constant time.
PartitionableListState<S>	Implementation of operator list state.
PartitionAggregateOperator<IN,ACC,OUT>	The `PartitionAggregateOperator` is used to apply the aggregate transformation on all records of each partition.
PartitionConnectionException	Exception for failed partition requests due to connection failure with unreachable producer.
PartitionDescriptor	Partition descriptor for `ShuffleMaster` to obtain `ShuffleDescriptor`.
PartitionedFile	`PartitionedFile` is the persistent file type of sort-merge based blocking shuffle.
PartitionedFileWriter	File writer which can write buffers and generate `PartitionedFile`.
PartitionException	Exception for covering all the scenarios of consuming partition failure which causes the consumer task failed, and the job master would decide whether to restart the producer based on this exception.
PartitionFileReader	`PartitionFileReader` defines the read logic for different types of shuffle files.
PartitionFileReader.ReadBufferResult	A wrapper class of the reading buffer result, including the read buffers, the hint of continue reading, and the read progress, etc.
PartitionFileReader.ReadProgress	This `PartitionFileReader.ReadProgress` defines the read progress of the `PartitionFileReader`.
PartitionFileWriter	The `PartitionFileWriter` interface defines the write logic for different types of shuffle files.
PartitionFileWriter.SegmentBufferContext	The `PartitionFileWriter.SegmentBufferContext` contains all the buffers belonging to the segment.
PartitionFileWriter.SubpartitionBufferContext	The `PartitionFileWriter.SubpartitionBufferContext` contains all the buffers belonging to one subpartition.
PartitionGroupReleaseStrategy	Interface for strategies that decide when to release `ConsumedPartitionGroups`.
PartitionGroupReleaseStrategy.Factory	Factory for `PartitionGroupReleaseStrategy`.
PartitionGroupReleaseStrategyFactoryLoader	Instantiates a `RegionPartitionGroupReleaseStrategy`.
PartitionInfo	Contains information where to find a partition.
PartitionNotFoundException	Exception for failed partition requests due to non-existing partitions.
PartitionProducerDisposedException	Exception returned to a TaskManager on JobMaster requesting partition state, if the producer of a partition has been disposed.
PartitionProducerStateChecker	Intermediate partition state checker to query the JobManager about the state of the producer of a result partition.
PartitionProducerStateProvider	Request execution state of partition producer, the response accepts state check callbacks.
PartitionProducerStateProvider.ResponseHandle	Result of state query, accepts state check callbacks.
PartitionReduceOperator<IN>	The `PartitionReduceOperator` is used to apply the reduce transformation on all records of each partition.
PartitionRequestClient	Client to send messages or task events via network for `RemoteInputChannel`.
PartitionRequestListener	When the netty server receives a downstream task's partition request event and finds its upstream task doesn't register its partition yet, the netty server will construct a `PartitionRequestListener` and notify the listener when the task deploys itself and registers its partition to `ResultPartitionManager`.
PartitionRequestListenerManager	Manages partition request listener with input channel id.
PartitionTable<K>	Thread-safe Utility for tracking partitions.
PartitionTracker<K,M>	Utility for tracking partitions.
PartitionTrackerEntry<K,M>	Encapsulates all information that a `PartitionTracker` keeps for a partition.
PartitionTrackerFactory	Factory for `JobMasterPartitionTracker`.
PartitionTrackerFactory.TaskExecutorGatewayLookup	Lookup function for `TaskExecutorGateway`.
PartitionTransformation<T>	This transformation represents a change of partitioning of the input elements.
PartitionTransformationTranslator<OUT>	A `TransformationTranslator` for the `PartitionTransformation`.
PartitionUpdateException	Exception indicating a problem with the result partitions on the `TaskExecutor` side.
PartitionWindowedStream<T>	`PartitionWindowedStream` represents a data stream that collects all records of each partition separately into a full window.
PartitionWithMetrics	Interface representing the description and metrics of a result partition.
PassThroughAllWindowFunction<W extends Window,T>	A `AllWindowFunction` that just emits each input element.
PassThroughWindowFunction<K,W extends Window,T>	A `WindowFunction` that just emits each input element.
PausableRelativeClock	A `RelativeClock` whose time progress with respect to the wall clock can be paused and un-paused.
PendingCheckpoint	A pending checkpoint is a checkpoint that has been started, but has not been acknowledged by all tasks that need to acknowledge it.
PendingCheckpoint.TaskAcknowledgeResult	Result of the `PendingCheckpoint.acknowledgedTasks` method.
PendingCheckpointStats	Statistics for a pending checkpoint that is still in progress.
PendingTaskManager	Represents a pending task manager in the `SlotManager`.
PendingTaskManagerId	Id of `PendingTaskManager`.
PeriodTimer	Interface for the measurement of the period of time.
PerJobCheckpointRecoveryFactory<T extends CompletedCheckpointStore>	Simple `CheckpointRecoveryFactory` which creates and keeps separate `CompletedCheckpointStore` and `CheckpointIDCounter` for each `JobID`.
PerJobCheckpointRecoveryFactory.CheckpointStoreRecoveryHelper<StoreType extends CompletedCheckpointStore>	Restores or creates a `CompletedCheckpointStore`, optionally using an existing one.
PermanentBlobCache	Provides a cache for permanent BLOB files including a per-job ref-counting and a staged cleanup.
PermanentBlobKey	BLOB key referencing permanent BLOB files.
PermanentBlobService	A service to retrieve permanent binary large objects (BLOBs).
PersistentMetadataCheckpointStorageLocation	A checkpoint storage location for the `MemCheckpointStreamFactory` when it durably persists the metadata in a file system.
PhysicalFile	An abstraction of physical files in file-merging checkpoints.
PhysicalFile.PhysicalFileCreator	Functional interface to create the physical file.
PhysicalFile.PhysicalFileDeleter	Functional interface to delete the physical file.
PhysicalFilePool	A pool for reusing `PhysicalFile`.
PhysicalFilePool.Type	Types of supported physical file pool.
PhysicalSlot	The context of an `AllocatedSlot`.
PhysicalSlot.Payload	Payload which can be assigned to an `AllocatedSlot`.
PhysicalSlotProvider	The provider serves physical slot requests.
PhysicalSlotProviderImpl	The provider serves physical slot requests.
PhysicalSlotRequest	Represents a request for a physical slot.
PhysicalSlotRequest.Result	Result of a `PhysicalSlotRequest`.
PhysicalSlotRequestBulk	Represents a bulk of physical slot requests.
PhysicalSlotRequestBulkChecker	This class tracks a fulfillability timeout of a bulk of physical slot requests.
PhysicalSlotRequestBulkCheckerImpl	Default implementation of `PhysicalSlotRequestBulkChecker`.
PhysicalStateHandleID	Unique ID that allows for physical comparison between state handles.
PhysicalTransformation<T>	A `Transformation` that creates a physical operation.
PipelinedApproximateSubpartition	A pipelined in-memory only subpartition, which allows to reconnect after failure.
PipelinedApproximateSubpartitionView	View over a pipelined in-memory only subpartition allowing reconnecting.
PipelinedRegion<VID extends VertexID,RID extends ResultID,V extends Vertex<VID,RID,V,R>,R extends Result<VID,RID,V,R>>	A pipelined region is a set of vertices connected via pipelined data exchanges.
PipelinedRegionComputeUtil	Common utils for computing pipelined regions.
PipelinedRegionSchedulingStrategy	`SchedulingStrategy` instance which schedules tasks in granularity of pipelined regions.
PipelinedRegionSchedulingStrategy.Factory	The factory for creating `PipelinedRegionSchedulingStrategy`.
PipelinedResultPartition	A result output of a task, pipelined (streamed) to the receivers.
PipelinedSubpartition	A pipelined in-memory only subpartition, which can be consumed once.
PipelinedSubpartitionView	View over a pipelined in-memory only subpartition.
PipelineErrorHandler	This is the last handler in the pipeline.
PlaceholderStreamStateHandle	A placeholder state handle for shared state that will replaced by an original that was created in a previous checkpoint.
PointwiseBlockingResultInfo	Information of Pointwise result.
PointwiseVertexInputInfoComputer	Helper class that computes VertexInputInfo for pointwise input.
PossibleInconsistentStateException	`PossibleInconsistentStateException` represents errors that might have lead to an inconsistent state within the HA resources.
PreferredAllocationRequestSlotMatchingStrategy	`RequestSlotMatchingStrategy` that takes the preferred allocations into account.
PreferredLocationsRetriever	Component to retrieve the preferred locations of an execution vertex.
PreviousAllocationSlotSelectionStrategy	This class implements a `SlotSelectionStrategy` that is based on previous allocations and falls back to using location preference hints if there is no previous allocation.
PrintSinkFunction<IN>	Deprecated. This interface will be removed in future versions.
PrioritizedDeque<T>	A deque-like data structure that supports prioritization of elements, such they will be polled before any non-priority elements.
PrioritizedOperatorSubtaskState	This class is a wrapper over multiple alternative `OperatorSubtaskState` that are (partial) substitutes for each other and imposes a priority ordering over all alternatives for the different states which define an order in which the operator should attempt to restore the state from them.
PrioritizedOperatorSubtaskState.Builder	A builder for PrioritizedOperatorSubtaskState.
PriorityComparable<T>	Interface for objects that can be compared by priority.
PriorityComparator<T>	This interface works similar to `Comparable` and is used to prioritize between two objects.
PriorityQueueSetFactory	Factory for `KeyGroupedInternalPriorityQueue` instances.
ProcessAllWindowFunction<IN,OUT,W extends Window>	Base abstract class for functions that are evaluated over non-keyed windows using a context for retrieving extra information.
ProcessFunction<I,O>	A function that processes elements of a stream.
ProcessingTimeService	Defines the current processing time and handles all related actions, such as register timers for tasks to be executed in the future.
ProcessingTimeServiceAware	Interface for `StreamOperatorFactory`, which enables stream operators to access `ProcessingTimeService`.
ProcessingTimeServiceFactory	A factory for creating processing time services with a given `MailboxExecutor`.
ProcessingTimeServiceUtil	Utility for classes that implements the `ProcessingTimeService` interface.
ProcessingTimeTrigger	A `Trigger` that fires once the current system time passes the end of the window to which a pane belongs.
ProcessJoinFunction<IN1,IN2,OUT>	A function that processes two joined elements and produces a single output one.
ProcessMemoryOptions	Common Flink's options to describe its JVM process memory configuration for JM or TM.
ProcessMemorySpec	Common interface for Flink JVM process memory components.
ProcessMemoryUtils<FM extends FlinkMemory>	Common utils to parse JVM process memory configuration for JM or TM.
ProcessMetricGroup	`AbstractImitatingJobManagerMetricGroup` implementation for process related metrics.
ProcessOperator<IN,OUT>	A `StreamOperator` for executing `ProcessFunctions`.
ProcessWindowFunction<IN,OUT,KEY,W extends Window>	Base abstract class for functions that are evaluated over keyed (grouped) windows using a context for retrieving extra information.
ProducerDescriptor	Partition producer descriptor for `ShuffleMaster` to obtain `ShuffleDescriptor`.
ProducerFailedException	Network-stack level Exception to notify remote receiver about a failed partition producer.
ProducerMergedPartitionFile	The partition file in the producer-merge mode.
ProducerMergedPartitionFileIndex	The `ProducerMergedPartitionFileIndex` is used by `ProducerMergedPartitionFileWriter` and `ProducerMergedPartitionFileReader`, to maintain the offset of each buffer in the physical file.
ProducerMergedPartitionFileIndex.FixedSizeRegion	Represents a series of buffers that are: From the same subpartition Logically (i.e. buffer index) consecutive Physically (i.e. offset in the file) consecutive
ProducerMergedPartitionFileReader	The implementation of `PartitionFileReader` with producer-merge mode.
ProducerMergedPartitionFileReader.ProducerMergedReadProgress	The implementation of `PartitionFileReader.ReadProgress` mainly includes current reading offset, end of read offset, etc.
ProducerMergedPartitionFileWriter	The implementation of `PartitionFileWriter` with producer-side merge mode.
ProfilingFileMessageParameters	Parameters for `JobManagerProfilingFileHandler`.
ProfilingFileNamePathParameter	Parameters used by `JobManagerProfilingFileHandler`.
ProfilingInfo	Contains information of a Profiling Instance.
ProfilingInfo.ProfilingMode	Supported profiling mode in async-profiler.
ProfilingInfo.ProfilingStatus	Profiling Status.
ProfilingInfoList	Class containing a collection of `ProfilingInfo`.
ProfilingRequestBody	`RequestBody` to trigger profiling instance.
ProfilingService	Create and keep profiling requests with rolling policy.
ProgressiveTimestampsAndWatermarks<T>	An implementation of `TimestampsAndWatermarks` that does periodic watermark emission and keeps track of watermarks on a per-split basis.
ProxyMetricGroup<P extends org.apache.flink.metrics.MetricGroup>	Metric group which forwards all registration calls to its parent metric group.
PullingAsyncDataInput<T>	Interface defining couple of essential methods for asynchronous and non blocking data polling.
PullingAsyncDataInput.EndOfDataStatus	Status for describing if we have reached the end of data.
PurgingTrigger<T,W extends Window>	A trigger that can turn any `Trigger` into a purging `Trigger`.
PushingAsyncDataInput<T>	The variant of `PullingAsyncDataInput` that is defined for handling both network input and source input in a unified way via `PushingAsyncDataInput.emitNext(DataOutput)` instead of returning `Optional.empty()` via `PullingAsyncDataInput.pollNext()`.
PushingAsyncDataInput.DataOutput<T>	Basic data output interface used in emitting the next element from data input.
PushSorter<E>	A push-based `Sorter`.
QueryableAppendingStateOperator<IN>	Internal operator handling queryable AppendingState instances.
QueryableStateConfiguration	Simple configuration object for the parameters for the server-side of queryable state.
QueryableStateStream<K,V>	Deprecated. The Queryable State feature is deprecated since Flink 1.18, and will be removed in a future Flink major version.
QueryableStateUtils	Utility class to initialize entities used in queryable state.
QueryableValueStateOperator<IN>	Internal operator handling queryable ValueState instances.
QueryScopeInfo	Container for scope related information as required by the MetricQueryService.
QueryScopeInfo.JobManagerOperatorQueryScopeInfo	Container for the job manager operator scope.
QueryScopeInfo.JobManagerQueryScopeInfo	Container for the job manager scope.
QueryScopeInfo.JobQueryScopeInfo	Container for the job scope.
QueryScopeInfo.OperatorQueryScopeInfo	Container for the operator scope.
QueryScopeInfo.TaskManagerQueryScopeInfo	Container for the task manager scope.
QueryScopeInfo.TaskQueryScopeInfo	Container for the task scope.
QueueStatus	Response type for temporary queue resources, i.e., resources that are asynchronously created.
QueueStatus.Id	Defines queue statuses.
QueuingCallback<T>	A `RequestDoneCallback` that adds the memory segments to a blocking queue.
QuickSort
RandomAccessInputView
RandomAccessOutputView
RangeBoundaryBuilder<T>	Build RangeBoundaries with input records.
RangeFraction	Range and fraction of a memory component, which is a capped fraction of another component.
RawJsonDeserializer	Json deserializer which deserializes raw json.
Reader<T extends org.apache.flink.core.io.IOReadableWritable>	A record-oriented reader for immutable record types.
ReaderBase	The basic API for every reader.
ReaderIterator<T>	A `MutableObjectIterator` that wraps a reader from an input channel and produces the reader's records.
ReaderRegistrationEvent	An `OperatorEvent` that registers a `SourceReader` to the SourceCoordinator.
ReadOnlySlicedNetworkBuffer	Minimal best-effort read-only sliced `Buffer` implementation wrapping a `NetworkBuffer`'s sub-region based on `io.netty.buffer.SlicedByteBuf` and `io.netty.buffer.ReadOnlyByteBuf`.
RebalancePartitioner<T>	Partitioner that distributes the data equally by cycling through the output channels.
RecordAttributes	A RecordAttributes describes the attributes of records from the current RecordAttributes until the next one is received.
RecordAttributesBuilder	The builder class for `RecordAttributes`.
RecordAttributesCombiner	RecordAttributesValve combine RecordAttributes from different input channels.
RecordContext<K>	A context that preserves the necessary variables required by each operation, all operations for one record will share the same element context.
RecordContext.DisposerRunner
RecordDeserializer<T extends org.apache.flink.core.io.IOReadableWritable>	Interface for turning sequences of memory segments into records.
RecordDeserializer.DeserializationResult	Status of the deserialization result.
RecordProcessorUtils	Utility class for creating record processor for `Input` `StreamOperator`.
RecordReader<T extends org.apache.flink.core.io.IOReadableWritable>	Record oriented reader for immutable types.
RecordWriter<T extends org.apache.flink.core.io.IOReadableWritable>	An abstract record-oriented runtime result writer.
RecordWriterBuilder<T extends org.apache.flink.core.io.IOReadableWritable>	Utility class to encapsulate the logic of building a `RecordWriter` instance.
RecordWriterDelegate<T extends org.apache.flink.core.io.IOReadableWritable>	The record writer delegate provides the availability function for task processor, and it might represent a single `RecordWriter` or multiple `RecordWriter` instances in specific implementations.
RecordWriterOutput<OUT>	Implementation of `Output` that sends data using a `RecordWriter`.
RecoverableStreamTaskInput<T>	A `StreamTaskInput` used during recovery of in-flight data.
RecoverableStreamWrapper	Implementation of `MetadataOutputStreamWrapper` encapsulates the `RecoverableFsDataOutputStream` for `FsCheckpointMetadataOutputStream`.
RecoveredInputChannel	An input channel reads recovered state from previous unaligned checkpoint snapshots.
RecoveryMetadata	`RecoveryMetadata` contains the metadata used during a recovery process.
RecreateOnResetOperatorCoordinator	A class that will recreate a new `OperatorCoordinator` instance when reset to checkpoint.
RecreateOnResetOperatorCoordinator.Provider	The provider for a private RecreateOnResetOperatorCoordinator.
RedirectingSslHandler	SSL handler which automatically redirects Non-SSL requests to SSL address.
ReduceApplyAllWindowFunction<W extends Window,T,R>	Internal `AllWindowFunction` that is used for implementing a fold on a window configuration that only allows `AllWindowFunction` and cannot directly execute a `ReduceFunction`.
ReduceApplyProcessAllWindowFunction<W extends Window,T,R>	Internal `ProcessAllWindowFunction` that is used for implementing a fold on a window configuration that only allows `AllWindowFunction` and cannot directly execute a `ReduceFunction`.
ReduceApplyProcessWindowFunction<K,W extends Window,T,R>	Internal `ProcessWindowFunction` that is used for implementing a fold on a window configuration that only allows `AllWindowFunction` and cannot directly execute a `ReduceFunction`.
ReduceApplyWindowFunction<K,W extends Window,T,R>	Internal `WindowFunction` that is used for implementing a fold on a window configuration that only allows `WindowFunction` and cannot directly execute a `ReduceFunction`.
ReduceCombineDriver<T>	Combine operator for Reduce functions, standalone (not chained).
ReduceDriver<T>	Reduce driver which is executed by a Task Manager.
ReduceTransformation<IN,K>	A `Transformation` that describes a reduce operation on a `KeyedStream`.
ReduceTransformationTranslator<IN,KEY>	A `TransformationTranslator` for the `ReduceTransformation`.
ReducingStateAdaptor<K,N,V>	An adaptor that transforms `InternalReducingState` into `InternalReducingState`.
ReferenceCounted<ReleaseHelper>	An object that can be reference counted, the internal resource would be released when the reference count reaches zero.
RegionPartitionGroupReleaseStrategy	Releases blocking intermediate result partitions that are incident to a `SchedulingPipelinedRegion`, as soon as the region's execution vertices are finished.
RegionPartitionGroupReleaseStrategy.Factory	Factory for `PartitionGroupReleaseStrategy`.
RegisteredBroadcastStateBackendMetaInfo<K,V>
RegisteredKeyValueStateBackendMetaInfo<N,S>	Compound meta information for a registered state in a keyed state backend.
RegisteredKeyValueStateBackendMetaInfo<N,S>	Compound meta information for a registered state in a keyed state backend.
RegisteredOperatorStateBackendMetaInfo<S>	Compound meta information for a registered state in an operator state backend.
RegisteredPriorityQueueStateBackendMetaInfo<T>	Meta information about a priority queue state in a backend.
RegisteredRpcConnection<F extends Serializable,G extends org.apache.flink.runtime.rpc.RpcGateway,S extends RegistrationResponse.Success,R extends RegistrationResponse.Rejection>	This utility class implements the basis of RPC connecting from one component to another component, for example the RPC connection from TaskExecutor to ResourceManager.
RegisteredStateMetaInfoBase	Base class for all registered state in state backends.
RegisteredStateMetaInfoBase.Key	Wrapper class that can be used to represent the wrapped `RegisteredStateMetaInfoBase` as key in a `Map`.
RegistrationConnectionListener<T extends RegisteredRpcConnection<?,?,S,?>,S extends RegistrationResponse.Success,R extends RegistrationResponse.Rejection>	Classes which want to be notified about the registration result by the `RegisteredRpcConnection` have to implement this interface.
RegistrationResponse	Base class for responses given to registration attempts from `RetryingRegistration`.
RegistrationResponse.Failure	A registration failure.
RegistrationResponse.Rejection	A rejected (declined) registration.
RegistrationResponse.Success	Base class for a successful registration.
RegistrationTimeoutException	Exception which indicates that the `TaskExecutor` could not register at the master in time.
RegularOperatorChain<OUT,OP extends StreamOperator<OUT>>	A regular non finished on restore `OperatorChain`.
RegularToMutableObjectIterator<T>
RelativeFileStateHandle	A `StreamStateHandle` for state that was written to a file stream.
RemoteChannelStateChecker	Handles the response of `PartitionProducerStateProvider`.
RemoteEnvironmentConfigUtils	A set of tools used by batch and streaming remote environments when preparing their configurations.
RemoteInputChannel	An input channel, which requests a remote partition queue.
RemoteRecoveredInputChannel	An input channel reads recovered state from previous unaligned checkpoint snapshots and then converts into `RemoteInputChannel` finally.
RemoteStorageScanner	The `RemoteStorageScanner` is introduced to notify asynchronously for file reading on remote storage.
RemoteStreamEnvironment	A `StreamExecutionEnvironment` for executing on a cluster.
RemoteTierConsumerAgent	The data client is used to fetch data from remote tier.
RemoteTierFactory	The implementation of `TierFactory` for remote tier.
RemoteTierMasterAgent	The implementation of `TierMasterAgent` for the remote tier.
RemoteTierProducerAgent	The implementation of `TierProducerAgent` for the remote tier.
RemoteTierShuffleDescriptor	The shuffle descriptor implementation for remote tier.
RemoteTransportException
RemoveRangeIndex<T>
ReOpenableHashPartition<BT,PT>
ReOpenableMutableHashTable<BT,PT>
ReportedWatermarkEvent	Reports last emitted `Watermark` from a subtask to the `SourceCoordinator`.
ReporterScopedSettings	Encapsulates all settings that are defined per reporter.
ReporterSetup	Encapsulates everything needed for the instantiation and configuration of a `MetricReporter`.
RequestBody	Marker interface for all requests of the REST API.
RequestDoneCallback<T>	Callback to be executed on completion of an asynchronous I/O request.
RequestJobDetails	This message requests an overview of the jobs on the JobManager, including running jobs and/or finished jobs.
RequestJobsOverview	This message requests an overview of how many jobs are in which status.
RequestJobsWithIDsOverview	This message requests an overview of how many jobs are in which status.
RequestQueue<E>	A `LinkedBlockingQueue` that is extended with closing methods.
RequestSlotMatchingStrategy	Strategy to match slot requests to slots.
RequestSlotMatchingStrategy.RequestSlotMatch	Result class representing matches.
RequestSplitEvent	An event to request splits, sent typically from the Source Reader to the Source Enumerator.
RequestStatusOverview	This message requests an overview of the status, such as how many TaskManagers are currently connected, how many slots are available, how many are free, ...
RequirementMatcher	A matcher for resource profiles to requirements.
RescaleMappings	Contains the fine-grain channel mappings that occur when a connected operator has been rescaled.
RescalePartitioner<T>	Partitioner that distributes the data equally by cycling through the output channels.
RescalingHandlers	Rest handler to trigger and poll the rescaling of a running job.
RescalingParallelismQueryParameter	Parallelism for the rescaling of jobs specified as a `MessageQueryParameter`.
RescalingStatusHeaders	Message headers for polling the status of an ongoing rescaling operation.
RescalingStatusMessageParameters	`MessageParameters` for polling the status of a rescaling operation.
RescalingStreamTaskNetworkInput<T>	A `StreamTaskNetworkInput` implementation that demultiplexes virtual channels.
RescalingTriggerHeaders	Message headers for triggering the rescaling of a job.
RescalingTriggerMessageParameters	`MessageParameters` for triggering the rescaling of a job.
ReservedSlots	Container for the set of reserved slots for `ExecutionVertexID`.
ReserveSlotFunction	A function for reserving slots.
ResettableDriver<S extends org.apache.flink.api.common.functions.Function,OT>	This interface marks a `Driver` as resettable, meaning that will reset part of their internal state but otherwise reuse existing data structures.
ResettableIterator<E>	The resettable iterator is a specialization of the iterator, allowing to reset the iterator and re-retrieve elements.
ResettableMutableObjectIterator<E>	The resettable iterator is a specialization of the iterator, allowing to reset the iterator and re-retrieve elements.
ResourceAllocationResult	Contains the results of the `ResourceAllocationStrategy`.
ResourceAllocationResult.Builder
ResourceAllocationStrategy	Strategy for allocating slots and task managers to fulfill the unfulfilled requirements.
ResourceAllocator	Resource related actions which the `SlotManager` can perform.
ResourceBudgetManager	Budget manager for `ResourceProfile`.
ResourceCleaner	`ResourceCleaner` executes instances on the given `JobID`.
ResourceCleanerFactory	`ResourceCleanerFactory` provides methods to create `ResourceCleaner` for local and global cleanup.
ResourceCounter	Counter for `ResourceProfiles`.
ResourceDeclaration	ResourceDeclaration for `ResourceAllocator`.
ResourceEventHandler<WorkerType extends ResourceIDRetrievable>	Callback interfaces for handling resource events from external resource managers.
ResourceEventListener	Listener for resource events of `SlotManager`.
ResourceID	Class for Resource Ids identifying Flink's distributed components.
ResourceIDDeserializer	Json deserializer for `ResourceID`.
ResourceIDRetrievable	An interface to retrieve the ResourceID of an object.
ResourceIDSerializer	Json serializer for `InstanceID`.
ResourceManager<WorkerType extends ResourceIDRetrievable>	ResourceManager implementation.
ResourceManagerAddress	Current address and fencing token of the leading ResourceManager.
ResourceManagerDriver<WorkerType extends ResourceIDRetrievable>	A `ResourceManagerDriver` is responsible for requesting and releasing resources from/to a particular external resource manager.
ResourceManagerException	Base class for `ResourceManager` exceptions.
ResourceManagerFactory<T extends ResourceIDRetrievable>	`ResourceManager` factory.
ResourceManagerGateway	The `ResourceManager`'s RPC gateway interface.
ResourceManagerId	Fencing token for the `ResourceManager`.
ResourceManagerMetricGroup	Metric group which is used by the `ResourceManager` to register metrics.
ResourceManagerPartitionTracker	Utility for tracking and releasing partitions on the ResourceManager.
ResourceManagerPartitionTrackerFactory	Factory for `ResourceManagerPartitionTracker`.
ResourceManagerPartitionTrackerImpl	Default `ResourceManagerPartitionTracker` implementation.
ResourceManagerProcessContext	This class contains information and services needed for creating a `ResourceManager`, which do not change during the lifetime of the process and can be reused between multiple resource manager instances in the process.
ResourceManagerRuntimeServices	Container class for the `ResourceManager` services.
ResourceManagerRuntimeServicesConfiguration	Configuration class for the `ResourceManagerRuntimeServices` class.
ResourceManagerService	Service that maintains lifecycle of `ResourceManager`.
ResourceManagerServiceImpl	Default implementation of `ResourceManagerService`.
ResourceManagerUtils	Common utils for ResourceManager.
ResourceOverview	Class containing information about the available cluster resources.
ResourceProfile	Describe the immutable resource profile of the slot, either when requiring or offering it.
ResourceProfile.Builder	Builder for the `ResourceProfile`.
ResourceProfileInfo	Contains information of a `ResourceProfile`.
ResourceReconcileResult	Contains the results of the `ResourceAllocationStrategy`.
ResourceReconcileResult.Builder
ResourceRequirement	Represents the number of required resources for a specific `ResourceProfile`.
ResourceRequirements	Represents the total resource requirements for a job, and the information required to connect to the corresponding job master.
ResourceTracker	Tracks for each job how many resource are required/acquired.
ResourceVersion<R>	Resource version for specific state handle on the underlying storage.
ResponseBody	Marker interface for all responses of the REST API.
RestAPIVersion<T extends RestAPIVersion<T>>	Interface for all versions of the REST API.
RestartAllFailoverStrategy	A failover strategy that proposes to restart all vertices when a vertex fails.
RestartAllFailoverStrategy.Factory	The factory to instantiate `RestartAllFailoverStrategy`.
RestartBackoffTimeStrategy	Strategy to decide whether to restart failed tasks and the delay to do the restarting.
RestartBackoffTimeStrategy.Factory	The factory to instantiate `RestartBackoffTimeStrategy`.
RestartBackoffTimeStrategyFactoryLoader	A utility class to load `RestartBackoffTimeStrategy.Factory` from the configuration.
RestartPipelinedRegionFailoverStrategy	A failover strategy that proposes to restart involved regions when a vertex fails.
RestartPipelinedRegionFailoverStrategy.Factory	The factory to instantiate `RestartPipelinedRegionFailoverStrategy`.
RestClient	This client is the counter-part to the `RestServerEndpoint`.
RestClientConfiguration	A configuration object for `RestClient`s.
RestClientException	An exception that is thrown if the failure of a REST operation was detected on the client.
RestConstants	This class contains constants to be used by rest components.
RestEndpointFactory<T extends RestfulGateway>	`WebMonitorEndpoint` factory.
RestfulGateway	Gateway for restful endpoints.
RestHandlerConfiguration	Configuration object containing values for the rest handler configuration.
RestHandlerException	An exception that is thrown if the failure of a REST operation was detected by a handler.
RestHandlerException.LoggingBehavior	Enum to control logging behavior of RestHandlerExceptions.
RestHandlerSpecification	Rest handler interface which all rest handler implementation have to implement.
RestMapperUtils	This class contains utilities for mapping requests and responses to/from JSON.
RestoredCheckpointStats	Statistics for a restored checkpoint.
RestoreOperation<R>	Interface for restore operation.
RestServerEndpoint	An abstract class for netty-based REST server endpoints.
RestServerEndpoint.RestHandlerUrlComparator	Comparator for Rest URLs.
RestServerEndpoint.RestHandlerUrlComparator.CaseInsensitiveOrderComparator	Comparator for Rest URLs.
RestServerEndpointConfiguration	A configuration object for `RestServerEndpoint`s.
RestService	Rest service interface.
Result<VID extends VertexID,RID extends ResultID,V extends Vertex<VID,RID,V,R>,R extends Result<VID,RID,V,R>>	Represents a data set produced by a `Vertex` Each result is produced by one `Vertex`.
ResultID	ID of a `Result`.
ResultPartition	A result partition for data produced by a single task.
ResultPartitionAvailabilityChecker	This checker helps to query result partition availability.
ResultPartitionBytes	This class represents a snapshot of the result partition bytes metrics.
ResultPartitionBytesCounter	This counter will count the data size of a partition.
ResultPartitionDeploymentDescriptor	Deployment descriptor for a result partition.
ResultPartitionFactory	Factory for `ResultPartition` to use in `NettyShuffleEnvironment`.
ResultPartitionID	Runtime identifier of a produced `IntermediateResultPartition`.
ResultPartitionManager	The result partition manager keeps track of all currently produced/consumed partitions of a task manager.
ResultPartitionMetrics	Collects metrics of a result partition.
ResultPartitionProvider	Interface for creating result partitions.
ResultPartitionState	State of a `SchedulingResultPartition`.
ResultPartitionType	Type of a result partition.
ResultPartitionWriter	A record-oriented runtime result writer API for producing results.
ResultSubpartition	A single subpartition of a `ResultPartition` instance.
ResultSubpartition.BufferAndBacklog	A combination of a `Buffer` and the backlog length indicating how many non-event buffers are available in the subpartition.
ResultSubpartitionIndexSet	A collection of subpartition indexes.
ResultSubpartitionInfo	Identifies `ResultSubpartition` in a given subtask.
ResultSubpartitionStateHandle	`Handle` to a `ResultSubpartition` state.
ResultSubpartitionView	A view to consume a `ResultSubpartition` instance.
ResultSubpartitionView.AvailabilityWithBacklog	Availability of the `ResultSubpartitionView` and the backlog in the corresponding `ResultSubpartition`.
RetrievableStateHandle<T extends Serializable>	Handle to state that can be read back again via `RetrievableStateHandle.retrieveState()`.
RetrievableStateStorageHelper<T extends Serializable>	State storage helper which is used by `StateHandleStore` to persist state before the state handle is written to the underlying system.
RetrievableStreamStateHandle<T extends Serializable>	Wrapper around a `StreamStateHandle` to make the referenced state object retrievable trough a simple get call.
RetryingRegistration<F extends Serializable,G extends org.apache.flink.runtime.rpc.RpcGateway,S extends RegistrationResponse.Success,R extends RegistrationResponse.Rejection>	This utility class implements the basis of registering one component at another component, for example registering the TaskExecutor at the ResourceManager.
RetryingRegistrationConfiguration	Configuration for the cluster components.
ReusingBlockResettableIterator<T>	Implementation of an iterator that fetches a block of data into main memory and offers resettable access to the data in that block.
ReusingBuildFirstHashJoinIterator<V1,V2,O>	An implementation of the `JoinTaskIterator` that uses a hybrid-hash-join internally to match the records with equal key.
ReusingBuildFirstReOpenableHashJoinIterator<V1,V2,O>
ReusingBuildSecondHashJoinIterator<V1,V2,O>	An implementation of the `JoinTaskIterator` that uses a hybrid-hash-join internally to match the records with equal key.
ReusingBuildSecondReOpenableHashJoinIterator<V1,V2,O>
ReusingDeserializationDelegate<T>	A `DeserializationDelegate` that reuses an existing instance upon deserialization.
ReusingKeyGroupedIterator<E>	The KeyValueIterator returns a key and all values that belong to the key (share the same key).
ReusingMergeInnerJoinIterator<T1,T2,O>
ReusingMergeOuterJoinIterator<T1,T2,O>
ReusingMutableToRegularIteratorWrapper<T>	This class wraps a `MutableObjectIterator` into a regular `Iterator`.
ReusingSortMergeCoGroupIterator<T1,T2>
RichParallelSourceFunction<OUT>	Deprecated. This class is based on the `SourceFunction` API, which is due to be removed.
RichSinkFunction<IN>	Deprecated. This interface will be removed in future versions.
RichSourceFunction<OUT>	Deprecated. This class is based on the `SourceFunction` API, which is due to be removed.
RightOuterJoinDriver<IT1,IT2,OT>	The right outer join driver implements the logic of an outer join operator at runtime.
RootExceptionHistoryEntry	`RootExceptionHistoryEntry` extending `ExceptionHistoryEntry` by providing a list of `ExceptionHistoryEntry` instances to store concurrently caught failures.
RoundRobinChannelSelector<T extends org.apache.flink.core.io.IOReadableWritable>	This is the default implementation of the `ChannelSelector` interface.
RoundRobinOperatorStateRepartitioner	Current default implementation of `OperatorStateRepartitioner` that redistributes state in round robin fashion.
RoundRobinSubpartitionSelector<T>	A `SubpartitionSelector` that selects all subpartitions in round-robin order.
RoutedRequest<T>	Class for handling `HttpRequest` with associated `RouteResult`.
Router<T>	This is adopted and simplified code from tv.cntt:netty-router library.
RouteResult<T>	This is adopted and simplified code from tv.cntt:netty-router library.
RouterHandler	Inbound handler that converts HttpRequest to Routed and passes Routed to the matched handler.
RpcCheckpointResponder
RpcGatewayRetriever<F extends Serializable,T extends org.apache.flink.runtime.rpc.FencedRpcGateway<F>>	`LeaderGatewayRetriever` implementation using the `RpcService`.
RpcGlobalAggregateManager
RpcInputSplitProvider
RpcKvStateRegistryListener	`KvStateRegistryListener` implementation for the new RPC service.
RpcMetricQueryServiceRetriever	`MetricQueryServiceRetriever` implementation for rpc based `MetricQueryService`.
RpcPartitionStateChecker
RpcServiceSharing	Enum which defines whether the mini cluster components use a shared RpcService or whether every component gets its own dedicated RpcService started.
RpcTaskManagerGateway	Implementation of the `TaskManagerGateway` for Flink's RPC system.
RpcTaskOperatorEventGateway	An OperatorEventSender that calls the RPC gateway `JobMasterOperatorEventGateway` to send the messages to the coordinator.
Runnables	Utils related to `Runnable`.
RuntimeAggregatorRegistry
RuntimeEnvironment	In implementation of the `Environment`.
RuntimeEvent	Subclasses of this event are recognized as events exchanged by the core runtime.
RuntimeMessageHeaders<R extends RequestBody,P extends ResponseBody,M extends MessageParameters>	This class links `RequestBody`s to `ResponseBody`s types and contains meta-data required for their http headers in runtime module.
RuntimeRestAPIVersion	An enum for all versions of the REST API.
RuntimeUntypedResponseMessageHeaders<R extends RequestBody,M extends MessageParameters>	Message headers for a web handler request that belongs to runtime module.
SavepointDisposalHandlers	Handlers to trigger the disposal of a savepoint.
SavepointDisposalRequest	Request body for a savepoint disposal call.
SavepointDisposalStatusHeaders	`AsynchronousOperationTriggerMessageHeaders` implementation for the `SavepointDisposalHandlers.SavepointDisposalStatusHandler`.
SavepointDisposalStatusMessageParameters	`MessageParameters` for the `SavepointDisposalHandlers.SavepointDisposalStatusHandler`.
SavepointDisposalTriggerHeaders	`AsynchronousOperationTriggerMessageHeaders` for the `SavepointDisposalHandlers.SavepointDisposalTriggerHandler`.
SavepointHandlers	HTTP handlers for asynchronous triggering of savepoints.
SavepointHandlers.SavepointStatusHandler	HTTP handler to query for the status of the savepoint.
SavepointInfo	Represents information about a finished savepoint.
SavepointKeyedStateHandle	A `KeyedStateHandle` that points to a savepoint taken in the unified format.
SavepointResources<K>	Savepoint resources for a `KeyedStateBackend`.
SavepointRestoreResult	A result from restoring a single `KeyedStateHandle`.
SavepointRestoreSettings	Savepoint restore settings.
SavepointSnapshotStrategy<K>	A `SnapshotStrategy` that produces unified savepoints.
SavepointStatusHeaders	These headers define the protocol for triggering a savepoint.
SavepointStatusMessageParameters	The parameters for triggering a savepoint.
SavepointTriggerHeaders	These headers define the protocol for triggering a savepoint.
SavepointTriggerMessageParameters	The parameters for triggering a savepoint.
SavepointTriggerRequestBody	`RequestBody` to trigger savepoints.
SavepointType	The type of checkpoint to perform.
SavepointType.PostCheckpointAction	What's the intended action after the checkpoint (relevant for stopping with savepoint).
ScalaProductFieldAccessorFactory	Interface to interact with optional Scala field accessors.
SchedulerBase	Base class which can be used to implement `SchedulerNG`.
SchedulerNG	Interface for scheduling Flink jobs.
SchedulerNGFactory	Factory for `SchedulerNG`.
SchedulerOperations	Component which is used by `SchedulingStrategy` to commit scheduling decisions.
SchedulerUtils	Utils class for Flink's scheduler implementations.
SchedulingExecutionVertex	Scheduling representation of `ExecutionVertex`.
SchedulingPipelinedRegion	Pipelined region on execution level, i.e., `ExecutionGraph` level.
SchedulingPipelinedRegionComputeUtil	Utils for computing `SchedulingPipelinedRegion`s.
SchedulingResultPartition	Representation of `IntermediateResultPartition`.
SchedulingStrategy	Component which encapsulates the scheduling logic.
SchedulingStrategyFactory	Factory interface for `SchedulingStrategy`.
SchedulingTopology	Topology of `SchedulingExecutionVertex`.
SchedulingTopologyListener	This listener will be notified whenever the scheduling topology is updated.
ScopeFormat	This class represents the format after which the "scope" (or namespace) of the various component metric groups is built.
ScopeFormats	A container for component scope formats.
SecurityConfiguration	The global security configuration.
SecurityContext	A security context with may be required to run a Callable.
SecurityContextFactory	A factory for a `SecurityContext`.
SecurityContextInitializeException	Indicates a problem with installing or uninstalling a security module or context.
SecurityFactoryServiceLoader	The Service provider discovery for searching suitable security factory.
SecurityModule	An installable security module.
SecurityModule.SecurityInstallException	Indicates a problem with installing or uninstalling a security module.
SecurityModuleFactory	A factory for a `SecurityModule`.
SecurityUtils	Security Environment that holds the security context and modules installed.
SeekableFileChannelInputView	A `DataInputView` that is backed by a `BlockChannelReader`, making it effectively a data input stream.
SegmentFileStateHandle	`FileStateHandle` for state that was written to a file segment.
SegmentPartitionFile	The partition file with segment file mode.
SegmentPartitionFileReader	The implementation of `PartitionFileReader` with segment file mode.
SegmentPartitionFileWriter	The implementation of `PartitionFileWriter` with segment file mode.
SequenceNumber	A logical timestamp to draw a boundary between the materialized and non-materialized changes.
SequenceNumber.GenericSequenceNumber	Generic `SequenceNumber`.
SequenceNumberRange
SequenceNumberRange.GenericSequenceNumberRange
SequentialChannelStateReader	Reads channel state saved during checkpoint/savepoint.
SequentialChannelStateReaderImpl	`SequentialChannelStateReader` implementation.
SerializationDelegate<T>	The serialization delegate exposes an arbitrary element as a `IOReadableWritable` for serialization, with the help of a type serializer.
SerializedCheckpointException	Serialized checkpoint exception which wraps the checkpoint failure reason and its serialized throwable.
SerializedCompositeKeyBuilder<K>	Responsible for serialization of currentKey, currentGroup and namespace.
SerializedInputSplit
SerializedJobExecutionResult	A variant of the `JobExecutionResult` that holds its accumulator data in serialized form.
SerializedThrowableDeserializer	JSON deserializer for `SerializedThrowable`.
SerializedThrowableSerializer	JSON serializer for `SerializedThrowable`.
SerializedUpdateBuffer	`AbstractPagedOutputView` used by the `BlockingBackChannel` for transmitting superstep results.
SerializedValueDeserializer	JSON deserializer for `SerializedValue`.
SerializedValueSerializer	JSON serializer for `SerializedValue`.
ServiceConnectionManager<S>	Base interface for managers of services that are explicitly connected to / disconnected from.
SessionClusterEntrypoint	Base class for session cluster entry points.
SessionDispatcherFactory	`DispatcherFactory` which creates a `StandaloneDispatcher`.
SessionDispatcherLeaderProcess	Process which encapsulates the job recovery logic and life cycle management of a `Dispatcher`.
SessionDispatcherLeaderProcessFactory	Factory for the `SessionDispatcherLeaderProcess`.
SessionDispatcherLeaderProcessFactoryFactory	Factory for the `SessionDispatcherLeaderProcessFactory`.
SessionRestEndpointFactory	`RestEndpointFactory` which creates a `DispatcherRestEndpoint`.
SharedResources	A map that keeps track of acquired shared resources and handles their allocation disposal.
SharedResources.ResourceAndSize<T extends AutoCloseable>	A resource handle with size.
SharedStateRegistry	This registry manages state that is shared across (incremental) checkpoints, and is responsible for deleting shared state that is no longer used in any valid checkpoint.
SharedStateRegistryFactory	Simple factory to produce `SharedStateRegistry` objects.
SharedStateRegistryImpl	`SharedStateRegistry` implementation.
SharedStateRegistryImpl.EmptyDiscardStateObjectForRegister	An object with empty discardState for registering.
SharedStateRegistryKey	This class represents a key that uniquely identifies (on a logical level) state handles for registration in the `SharedStateRegistry`.
SharingPhysicalSlotRequestBulk	Implementation of `PhysicalSlotRequestBulk` for `SlotSharingExecutionSlotAllocator`.
ShipStrategyType	Enumeration defining the different shipping types of the output, such as local forward, re-partitioning by hash, or re-partitioning by range.
ShuffleDescriptor	Interface for shuffle deployment descriptor of result partition resource.
ShuffleDescriptorRetriever	The retriever for shuffle descriptor.
ShuffleEnvironment<P extends ResultPartitionWriter,G extends IndexedInputGate>	Interface for the implementation of shuffle service local environment.
ShuffleEnvironmentContext	Local context used to create `ShuffleEnvironment`.
ShuffleIOOwnerContext	Context of shuffle input/output owner used to create partitions or gates belonging to the owner.
ShuffleMaster<T extends ShuffleDescriptor>	Intermediate result partition registry to use in `JobMaster`.
ShuffleMasterContext	Shuffle context used to create `ShuffleMaster`.
ShuffleMasterContextImpl	The default implementation of `ShuffleMasterContext`.
ShuffleMasterSnapshot	This class represents a snapshot of shuffle master, which can be used to restore the internal state of the shuffle master.
ShuffleMasterSnapshotContext	Snapshot context used to create `ShuffleMasterSnapshot`.
ShuffleMasterSnapshotUtil	Utility class for handling cluster-level snapshots for the ShuffleMaster.
ShuffleMetrics	Interface provides access to the shuffle metrics which includes the meta information of partition(partition bytes, etc).
ShufflePartitioner<T>	Partitioner that distributes the data equally by selecting one output channel randomly.
ShuffleServiceFactory<SD extends ShuffleDescriptor,P extends ResultPartitionWriter,G extends IndexedInputGate>	Interface for shuffle service factory implementations.
ShuffleServiceLoader	Utility to load the pluggable `ShuffleServiceFactory` implementations.
ShuffleServiceOptions	Options to configure shuffle service.
ShuffleUtils	Common utility methods for shuffle service.
ShutdownHandler	REST handler which allows to shut down the cluster.
ShutdownHeaders	Message headers for `ShutdownHandler`.
SideOutputDataStream<T>	A `SideOutputDataStream` represents a `DataStream` that contains elements that are emitted from upstream into a side output with some tag.
SideOutputTransformation<T>	This transformation represents a selection of a side output of an upstream operation with a given `OutputTag`.
SideOutputTransformationTranslator<OUT>	A `TransformationTranslator` for the `SideOutputTransformation`.
SignalHandler	This signal handler / signal logger is based on Apache Hadoop's org.apache.hadoop.util.SignalLogger.
SimpleCloseableInputProvider<E>	A simple iterator provider that returns a supplied iterator and does nothing when closed.
SimpleCollectingOutputView	The list with the full segments contains at any point all completely full segments, plus the segment that is currently filled.
SimpleExecutionSlotAllocator	A simple implementation of `ExecutionSlotAllocator`.
SimpleExecutionSlotAllocator.Factory	Factory to instantiate a `SimpleExecutionSlotAllocator`.
SimpleInitializeOnMasterContext	A simple pojo based implementation of `JobVertex.InitializeOnMasterContext`.
SimpleInputFormatOperatorFactory<OUT>	Input format source operator factory which just wrap existed `StreamSource`.
SimpleOperatorFactory<OUT>	Simple factory which just wrap existed `StreamOperator`.
SimpleOutputFormatOperatorFactory<IN,OUT>	A simple operator factory which create an operator containing an `OutputFormat`.
SimpleRequestSlotMatchingStrategy	Simple implementation of the `RequestSlotMatchingStrategy` that matches the pending requests in order as long as the resource profile can be fulfilled.
SimpleTimerService	Implementation of `TimerService` that uses a `InternalTimerService`.
SimpleTransformationTranslator<OUT,T extends org.apache.flink.api.dag.Transformation<OUT>>	A base class for all `TransformationTranslators` who translate `Transformations` that have a single operator in their runtime implementation.
SimpleUdfStreamOperatorFactory<OUT>	Udf stream operator factory which just wrap existed `AbstractUdfStreamOperator`.
SimpleVersionedListState<T>	A `ListState` that uses a `SimpleVersionedSerializer` instead of a `TypeSerializer`.
SingleCheckpointBarrierHandler	`SingleCheckpointBarrierHandler` is used for triggering checkpoint while reading the first barrier and keeping track of the number of received barriers and consumed barriers.
SingleElementIterator<E>	An `Iterator` that contains only a single element.
SingleInputGate	An input gate consumes one or more partitions of a single produced intermediate result.
SingleInputGateFactory	Factory for `SingleInputGate` to use in `NettyShuffleEnvironment`.
SingleInputGateFactory.ChannelStatistics	Statistics of input channels.
SingleLogicalSlot	Implementation of the `LogicalSlot`.
SingleOutputStreamOperator<T>	`SingleOutputStreamOperator` represents a user defined transformation applied on a `DataStream` with one predefined output type.
SingleRecordWriter<T extends org.apache.flink.core.io.IOReadableWritable>	The specific delegate implementation for the single output case.
SinkFunction<IN>	Deprecated. This interface will be removed in future versions.
SinkFunction.Context	Context that `SinkFunctions` can use for getting additional data about an input record.
SinkTransformation<InputT,OutputT>	A `Transformation` for `Sink`.
SinkTransformationTranslator<Input,Output>	A `TransformationTranslator` for the `SinkTransformation`.
SinkV1CommittableDeserializer	This class offers the possibility to deserialize committables that have been written with older Flink releases (i.e. 1.13, 1.14).
SinkWriterOperatorFactory<InputT,CommT>	A `StreamOperatorFactory` for `SinkWriterOperator`.
SlidingEventTimeWindows	A `WindowAssigner` that windows elements into sliding windows based on the timestamp of the elements.
SlidingProcessingTimeWindows	A `WindowAssigner` that windows elements into sliding windows based on the current system time of the machine the operation is running on.
SlotActions	Interface to trigger slot actions from within the `TaskSlotTable`.
SlotAllocationException	Exception indicating that the slot allocation on the task manager failed.
SlotAllocationSnapshot	Model to save local slot allocation info.
SlotAllocationSnapshotPersistenceService	Service for persisting `SlotAllocationSnapshot`.
SlotAllocator	Component for calculating the slot requirements and mapping of vertices to slots.
SlotAssigner	Interface for assigning slots to slot sharing groups.
SlotContext	Interface for the context of a `LogicalSlot`.
SlotID	Unique identifier for a slot on a TaskManager.
SlotInfo	Interface that provides basic information in the context of a slot.
SlotInfo	Class containing information for a slot of `TaskManagerSlotInformation`.
SlotManager	The slot manager is responsible for maintaining a view on all registered task manager slots, their allocation and all pending slot requests.
SlotManager.RegistrationResult	The result of task manager registration.
SlotManagerConfiguration	Configuration for the `SlotManager`.
SlotManagerException	Base class for exceptions thrown by the `SlotManager`.
SlotManagerMetricGroup	Metric group which is used by the `SlotManager` to register metrics.
SlotManagerUtils	Utilities for `SlotManager` implementations.
SlotNotActiveException	Exception indicating that the given `TaskSlot` was not in state active.
SlotNotFoundException	Exception indicating that a `TaskSlot` could not be found.
SlotOccupiedException	Exception which signals that a slot is already occupied by the given `AllocationID`.
SlotOffer	Describe the slot offering to job manager provided by task manager.
SlotOwner	Interface for components that hold slots and to which slots get released / recycled.
SlotPool	The Interface of a slot pool that manages slots.
SlotPoolService	Service used by the `JobMaster` to manage a slot pool.
SlotPoolServiceFactory	Factory interface for `SlotPoolService`.
SlotPoolServiceSchedulerFactory	Factory for `SlotPoolService` and `SchedulerNG`.
SlotProfile	A slot profile describes the profile of a slot into which a task wants to be scheduled.
SlotReport	A report about the current status of all slots of the TaskExecutor, describing which slots are available and allocated, and what jobs (JobManagers) the allocated slots have been allocated to.
SlotRequestId	This ID identifies the request for a slot from the Execution to the `SlotPool` or `PhysicalSlotProvider`.
SlotSelectionStrategy	Interface for slot selection strategies.
SlotSelectionStrategy.SlotInfoAndLocality	This class is a value type that combines a `SlotInfo` with a `Locality` hint.
SlotSelectionStrategyUtils	Utility class for selecting `SlotSelectionStrategy`.
SlotSharingExecutionSlotAllocatorFactory	Factory for `SlotSharingExecutionSlotAllocator`.
SlotSharingGroup	A slot sharing units defines which different task (from different job vertices) can be deployed together within a slot.
SlotSharingGroupId
SlotSharingGroupIDDeserializer	Jackson deserializer for `SlotSharingGroupId`.
SlotSharingGroupIDSerializer	Jackson serializer for `SlotSharingGroupId`.
SlotSharingSlotAllocator	`SlotAllocator` implementation that supports slot sharing.
SlotStatus	This describes the slot current status which located in TaskManager.
SlotStatusSyncer	Syncer for slot status.
SlowTaskDetector	Component responsible for detecting slow tasks.
SlowTaskDetectorListener	Component responsible for listening on slow tasks.
SnappyStreamCompressionDecorator	This implementation decorates the stream with snappy compression.
Snapshotable<S extends StateObject>	Interface for objects that can snapshot its state (state backends currently).
SnapshotDirectory	This class represents a directory that is the target for a state snapshot.
SnapshotExecutionType	Determines how the write-part of a snapshot should be executed.
SnapshotResources	A set of resources produced in the synchronous part of a snapshot required to finish the snapshot.
SnapshotResult<T extends StateObject>	This class contains the combined results from the snapshot of a state backend: A state object representing the state that will be reported to the Job Manager to acknowledge the checkpoint.
SnapshotStrategy<S extends StateObject,SR extends SnapshotResources>	Interface for different snapshot approaches in state backends.
SnapshotStrategy.SnapshotResultSupplier<S extends StateObject>	A supplier for a `SnapshotResult` with an access to a `CloseableRegistry` for io tasks that need to be closed when cancelling the async part of the checkpoint.
SnapshotStrategyRunner<T extends StateObject,SR extends SnapshotResources>	A class to execute a `SnapshotStrategy`.
SnapshotType	The type of checkpoint to perform.
SnapshotType.SharingFilesStrategy	Defines what files can be shared across snapshots.
SocketClientSink<IN>	Deprecated. This interface will be removed in future versions.
SocketTextStreamFunction	Deprecated. This class is based on the `SourceFunction` API, which is due to be removed.
SolutionSetBroker	Used to hand over the hash-join from the iteration head to the solution-set match.
SolutionSetFastUpdateOutputCollector<T>	A `Collector` to update the solution set of a workset iteration.
SolutionSetObjectsUpdateOutputCollector<T>	A `Collector` to update the solution set of a workset iteration.
SolutionSetUpdateBarrier	Resettable barrier to synchronize the `IterationHeadTask` and the `IterationTailTask` in case of iterations that contain a separate solution set tail.
SolutionSetUpdateBarrierBroker	Broker to hand over `SolutionSetUpdateBarrier` from `IterationHeadTask` to `IterationTailTask`.
SolutionSetUpdateOutputCollector<T>	A `Collector` to update the solution set of a workset iteration.
SortBasedDataBuffer	When getting buffers, The `SortBasedDataBuffer` should recycle the read target buffer with the given `BufferRecycler`.
SortBuffer	A `DataBuffer` implementation which sorts all appended records only by subpartition index.
SortBufferAccumulator	The sort-based implementation of the `BufferAccumulator`.
Sorter<E>	The SortMerger interface representing the public interface to all specific Sort-Merge implementations.
SortingDataInput<T,K>	A `StreamTaskInput` which sorts in the incoming records from a chained input.
SortMergeResultPartition	`SortMergeResultPartition` appends records and events to `DataBuffer` and after the `DataBuffer` is full, all data in the `DataBuffer` will be copied and spilled to a `PartitionedFile` in subpartition index order sequentially.
SortPartitionOperator<INPUT>	The `SortPartitionOperator` sorts records of a partition on non-keyed data stream.
SourceCoordinator<SplitT extends org.apache.flink.api.connector.source.SourceSplit,EnumChkT>	The default implementation of the `OperatorCoordinator` for the `Source`.
SourceCoordinator.WatermarkElement	The watermark element for `HeapPriorityQueue`.
SourceCoordinatorContext<SplitT extends org.apache.flink.api.connector.source.SourceSplit>	A context class for the `OperatorCoordinator`.
SourceCoordinatorProvider<SplitT extends org.apache.flink.api.connector.source.SourceSplit>	The provider of `SourceCoordinator`.
SourceCoordinatorProvider.CoordinatorExecutorThreadFactory	A thread factory class that provides some helper methods.
SourceCoordinatorSerdeUtils	A serialization util class for the `SourceCoordinator`.
SourceEventWrapper	A wrapper operator event that contains a custom defined operator event.
SourceFunction<T>	Deprecated. This interface will be removed in future versions.
SourceFunction.SourceContext<T>	Interface that source functions use to emit elements, and possibly watermarks.
SourceLineageVertex	Lineage vertex for source which has `Boundedness` to indicate whether the data for the source is bounded.
SourceOperator<OUT,SplitT extends org.apache.flink.api.connector.source.SourceSplit>	Base source operator only used for integrating the source reader which is proposed by FLIP-27.
SourceOperatorFactory<OUT>	The Factory class for `SourceOperator`.
SourceOperatorStreamTask<T>	A subclass of `StreamTask` for executing the `SourceOperator`.
SourceOperatorStreamTask.AsyncDataOutputToOutput<T>	Implementation of `PushingAsyncDataInput.DataOutput` that wraps a specific `Output`.
SourceOutputWithWatermarks<T>	Implementation of the SourceOutput.
SourceStreamTask<OUT,SRC extends SourceFunction<OUT>,OP extends StreamSource<OUT,SRC>>	Deprecated. This class is based on the `SourceFunction` API, which is due to be removed.
SourceTransformation<OUT,SplitT extends org.apache.flink.api.connector.source.SourceSplit,EnumChkT>	A `PhysicalTransformation` for `Source`.
SourceTransformationTranslator<OUT,SplitT extends org.apache.flink.api.connector.source.SourceSplit,EnumChkT>	A `TransformationTranslator` for the `SourceTransformation`.
SourceTransformationWrapper<T>	This Transformation is a phantom transformation which is used to expose a default parallelism to downstream.
SpeculativeExecutionHandler	Interface for managing speculative execution of tasks and handling slow task detection.
SpeculativeExecutionJobVertex	The ExecutionJobVertex which supports speculative execution.
SpeculativeExecutionJobVertex.Factory	Factory to create `SpeculativeExecutionJobVertex`.
SpeculativeExecutionVertex	The ExecutionVertex which supports speculative execution.
SpillingAdaptiveSpanningRecordDeserializer<T extends org.apache.flink.core.io.IOReadableWritable>
SpillingBuffer	An output view that buffers written data in memory pages and spills them when they are full.
SpillingResettableIterator<T>	Implementation of a resettable iterator.
SpillingResettableMutableObjectIterator<T>	Implementation of a resettable iterator.
SplitAssignmentTracker<SplitT extends org.apache.flink.api.connector.source.SourceSplit>	A class that is responsible for tracking the past split assignments made by `SplitEnumerator`.
SsgNetworkMemoryCalculationUtils	Util to analyze inputs & outputs of `ExecutionJobVertex` and calculate network memory requirement for slot sharing group (SSG).
SSLHandlerFactory	Creates and configures `SslHandler` instances.
SSLUtils	Common utilities to manage SSL transport settings.
StageRunner	An interface for different stages of the sorting process.
StageRunner.SortStage	A marker interface for sending messages to different stages.
StageRunner.StageMessageDispatcher<E>	A dispatcher for inter-stage communication.
StandaloneCheckpointIDCounter	`CheckpointIDCounter` instances for JobManagers running in `HighAvailabilityMode.NONE`.
StandaloneCheckpointRecoveryFactory	`CheckpointCoordinator` components in `HighAvailabilityMode.NONE`.
StandaloneClientHAServices	Non-HA implementation for `ClientHighAvailabilityServices`.
StandaloneCompletedCheckpointStore	`CompletedCheckpointStore` for JobManagers running in `HighAvailabilityMode.NONE`.
StandaloneDispatcher	Dispatcher implementation which spawns a `JobMaster` for each submitted `JobGraph` within in the same process.
StandaloneExecutionPlanStore	`ExecutionPlan` instances for JobManagers running in `HighAvailabilityMode.NONE`.
StandaloneHaServices	An implementation of the `HighAvailabilityServices` for the non-high-availability case.
StandaloneLeaderElection	`StandaloneLeaderElection` implements `LeaderElection` for non-HA cases.
StandaloneLeaderRetrievalService	Standalone implementation of the `LeaderRetrievalService`.
StandaloneResourceManager	A standalone implementation of the resource manager.
StandaloneResourceManagerFactory	`ResourceManagerFactory` which creates a `StandaloneResourceManager`.
StandaloneSessionClusterEntrypoint	Entry point for the standalone session cluster.
StandardSinkTopologies	This utility class provides building blocks for custom topologies.
StateAdaptor<K,N,S extends InternalKvState<K,N,?>>	An base implementation of state adaptor from v1 to v2.
StateAssignmentOperation	This class encapsulates the operation of assigning restored state when restoring from a checkpoint.
StateBackend	A State Backend defines how the state of a streaming application is stored locally within the cluster.
StateBackend.CustomInitializationMetrics
StateBackend.KeyedStateBackendParameters<K>	Parameters passed to `StateBackend.createKeyedStateBackend(KeyedStateBackendParameters)`.
StateBackend.OperatorStateBackendParameters	Parameters passed to `StateBackend.createOperatorStateBackend(OperatorStateBackendParameters)`.
StateBackendBuilder<T,E extends Throwable>	A mutable builder to build a state backend instance.
StateBackendFactory<T extends StateBackend>	A factory to create a specific state backend.
StateBackendLoader	This class contains utility methods to load state backends from configurations.
StateChange	Change of state of a keyed operator.
StateChangelogHandleReader<Handle extends ChangelogStateHandle>	Allows to read state changelog referenced by the provided `ChangelogStateHandle`.
StateChangelogHandleStreamHandleReader	A reader for `ChangelogStateHandleStreamImpl` that iterates over its underlying `stream handles` and offsets.
StateChangelogHandleStreamHandleReader.StateChangeIterator	Reads a stream of state changes starting from a specified offset.
StateChangelogStorage<Handle extends ChangelogStateHandle>	A storage for changelog.
StateChangelogStorageFactory	A factory for `StateChangelogStorage`.
StateChangelogStorageLoader	A thin wrapper around `PluginManager` to load `StateChangelogStorage`.
StateChangelogStorageView<Handle extends ChangelogStateHandle>	A storage view for changelog.
StateChangelogWriter<Handle extends ChangelogStateHandle>	Allows to write data to the log.
StateDescriptorUtils	Utilities for transforming `StateDescriptor` to `StateDescriptor`.
StateEntry<K,N,S>	Interface of entries in a state backend.
StateEntry.SimpleStateEntry<K,N,S>
StateExecutor	Executor for executing batch `StateRequest`s.
StateFactory<T extends org.apache.flink.runtime.scheduler.adaptive.State>	Factory for creating adaptive scheduler state instances.
StatefulSequenceSource	Deprecated. This class is based on the `SourceFunction` API, which is due to be removed.
StateFutureFactory<K>	An internal factory for `InternalStateFuture` that build future with necessary context switch and wired with mailbox executor.
StateHandleID	Unique ID that allows for logical comparison between state handles.
StateHandleStore<T extends Serializable,R extends ResourceVersion<R>>	Class which stores state via the provided `RetrievableStateStorageHelper` and writes the returned state handle to distributed coordination system(e.g.
StateHandleStore.AlreadyExistException	The key already exists in ConfigMap or the Zookeeper node already exists.
StateHandleStore.NotExistException	The key does not exist in ConfigMap or the Zookeeper node does not exists.
StateHandleStoreUtils	`StateHandleStoreUtils` collects utility methods that might be usefule for any `StateHandleStore` implementation.
StateInitializationContext	This interface provides a context in which operators can initialize by registering to managed state (i.e. state that is managed by state backends) or iterating over streams of state partitions written as raw state in a previous snapshot.
StateInitializationContextImpl	Default implementation of `StateInitializationContext`.
StateLocalitySlotAssigner	A `SlotAssigner` that assigns slots based on the number of local key groups.
StateLocationRetriever	Component to retrieve the state location of an execution vertex.
StateMap<K,N,S>	Base class for state maps.
StateMapSnapshot<K,N,S,T extends StateMap<K,N,S>>	Base class for snapshots of a `StateMap`.
StateMetaInfoReader	Functional interface to read `StateMetaInfoSnapshot`.
StateMetaInfoSnapshot	Generalized snapshot for meta information about one state in a state backend (e.g.
StateMetaInfoSnapshot.BackendStateType	Enum that defines the different types of state that live in Flink backends.
StateMetaInfoSnapshot.CommonOptionsKeys	Predefined keys for the most common options in the meta info.
StateMetaInfoSnapshot.CommonSerializerKeys	Predefined keys for the most common serializer types in the meta info.
StateMetaInfoSnapshotReadersWriters	Static factory that gives out the write and readers for different versions of `StateMetaInfoSnapshot`.
StateMetaInfoWriter	Functional interface to write `StateMetaInfoSnapshot`.
StateObject	Base of all handles that represent checkpointed state in some form.
StateObject.StateObjectLocation	Enum for state locations.
StateObject.StateObjectSizeStatsCollector	Collector for size and location stats from a state object via `StateObject.collectSizeStats(StateObjectSizeStatsCollector)`.
StateObjectCollection<T extends StateObject>	This class represents a generic collection for `StateObject`s.
StateObjectCollectionSerializer
StatePartitionStreamProvider	This class provides access to input streams that contain data of one state partition of a partitionable state.
StateRequest<K,N,IN,OUT>	A request encapsulates the necessary data to perform a state request.
StateRequestBuffer<K>	A buffer to hold state requests to execute state requests in batch, which can only be manipulated within task thread.
StateRequestContainer	A container which is used to hold `StateRequest`s.
StateRequestHandler	The handler which can process `StateRequest`.
StateRequestType	The type of processing request for `State` from users' perspective.
StateSerializerProvider<T>	A `StateSerializerProvider` wraps logic on how to obtain serializers for registered state, either with the previous schema of state in checkpoints or the current schema of state.
StateSizeEstimates	Managed Keyed State size estimates used to make scheduling decisions.
StateSnapshot	General interface for state snapshots that should be written partitioned by key-groups.
StateSnapshot.StateKeyGroupWriter	Interface for writing a snapshot that is partitioned into key-groups.
StateSnapshotContext	This interface provides a context in which operators that use managed (i.e. state that is managed by state backends) or raw (i.e. the operator can write it's state streams) state can perform a snapshot.
StateSnapshotContextSynchronousImpl	This class is a default implementation for StateSnapshotContext.
StateSnapshotKeyGroupReader	Interface for state de-serialization into `StateTable`s by key-group.
StateSnapshotRestore	Interface to deal with state snapshot and restore of state.
StateSnapshotTransformer<T>	Transformer of state values which are included or skipped in the snapshot.
StateSnapshotTransformer.CollectionStateSnapshotTransformer<T>	Collection state specific transformer which says how to transform entries of the collection.
StateSnapshotTransformer.CollectionStateSnapshotTransformer.TransformStrategy
StateSnapshotTransformer.StateSnapshotTransformFactory<T>	This factory creates state transformers depending on the form of values to transform.
StateSnapshotTransformers	Collection of common state snapshot transformers and their factories.
StateSnapshotTransformers.ListStateSnapshotTransformer<T>	General implementation of list state transformer.
StateSnapshotTransformers.ListStateSnapshotTransformFactory<T>
StateSnapshotTransformers.MapStateSnapshotTransformer<K,V>	General implementation of map state transformer.
StateSnapshotTransformers.MapStateSnapshotTransformFactory<K,V>
StateSnapshotTransformers.StateSnapshotTransformFactoryWrapAdaptor<S,T>
StateTable<K,N,S>	Base class for state tables.
StateTableByKeyGroupReaders	This class provides a static factory method to create different implementations of `StateSnapshotKeyGroupReader` depending on the provided serialization format version.
StateTimeMetric	Utility to define metrics that capture the time that some component spends in a state.
StateTransformationFunction<S,T>	Interface for a binary function that is used for push-down of state transformation into state backends.
StateTransitionManager	The `StateTransitionManager` decides on whether `AdaptiveScheduler` state transition should happen or not.
StateTransitionManager.Context	The interface that can be used by the `StateTransitionManager` to communicate with the underlying system.
StateTransitions	An interface covering all possible `State` transitions.
StateTransitions.ToCancelling	Interface covering transition to the `Canceling` state.
StateTransitions.ToCreatingExecutionGraph	Interface covering transition to the `CreatingExecutionGraph` state.
StateTransitions.ToExecuting	Interface covering transition to the `Executing` state.
StateTransitions.ToFailing	Interface covering transition to the `Failing` state.
StateTransitions.ToFinished	Interface covering transition to the `Finished` state.
StateTransitions.ToRestarting	Interface covering transition to the `Restarting` state.
StateTransitions.ToStopWithSavepoint	Interface covering transition to the `StopWithSavepoint` state.
StateTransitions.ToWaitingForResources	Interface covering transition to the `WaitingForResources` state.
StateUtil	Helpers for `StateObject` related code.
StateWithDeclaredNamespace<K,N,V>	A partitioned state that wraps a declared namespace and hide the namespace switching from user.
StaticExternalResourceInfoProvider	Static implementation of `ExternalResourceInfoProvider` which return fixed collection of `ExternalResourceInfo`.
StaticFileServerHandler<T extends RestfulGateway>	Simple file server handler that serves requests to web frontend's static files, such as HTML, CSS, or JS files.
Statistics	Represents one or more statistics samples.
StatsSummary	Aggregated values of some measurement such as min/max/average state size.
StatsSummaryDto	Transfer object for `statistics summary`.
StatsSummarySnapshot	Immutable snapshot of `StatsSummary`.
StatusDurationUtils	Utilities to calculate status duration.
StatusWatermarkValve	A `StatusWatermarkValve` embodies the logic of how `Watermark` and `WatermarkStatus` are propagated to downstream outputs, given a set of one or multiple subpartitions that continuously receive them.
StatusWatermarkValve.SubpartitionStatus	An `SubpartitionStatus` keeps track of a subpartition's last watermark, stream status, and whether or not the subpartition's current watermark is aligned with the overall watermark output from the valve.
StopMode	Tells if the job is stopping because of consuming all data.
StoppedDispatcherLeaderProcess	`DispatcherLeaderProcess` implementation which is stopped.
StopWithSavepointRequestBody	`RequestBody` for stopping a job with a savepoint.
StopWithSavepointStoppingException	Exception thrown when a savepoint has been created successfully when stopping with savepoint, but the job has not finished.
StopWithSavepointTerminationHandler	`StopWithSavepointTerminationHandler` handles the steps necessary for the stop-with-savepoint operation to finish.
StopWithSavepointTerminationHandlerImpl	`StopWithSavepointTerminationHandlerImpl` implements `StopWithSavepointTerminationHandler`.
StopWithSavepointTerminationManager	`StopWithSavepointTerminationManager` fulfills the contract given by `StopWithSavepointTerminationHandler` to run the stop-with-savepoint steps in a specific order.
StopWithSavepointTriggerHeaders	These headers define the protocol for triggering a "stop" action.
StreamCompressionDecorator	Implementations of this interface decorate streams with a compression scheme.
StreamConfig	Internal configuration for a `StreamOperator`.
StreamConfig.InputConfig	Interface representing chained inputs.
StreamConfig.InputRequirement	Requirements of the different inputs of an operator.
StreamConfig.NetworkInputConfig	A representation of a Network `StreamConfig.InputConfig`.
StreamConfig.SourceInputConfig	A serialized representation of an input.
StreamEdge	An edge in the streaming topology.
StreamEdgeUpdateRequestInfo	Helper class carries the data required to updates a stream edge.
StreamElement	An element in a data stream.
StreamElementSerializer<T>	Serializer for `StreamRecord`, `Watermark`, `LatencyMarker`, and `WatermarkStatus`.
StreamElementSerializer.StreamElementSerializerSnapshot<T>	Configuration snapshot specific to the `StreamElementSerializer`.
StreamExchangeMode	The data exchange mode between operators during `StreamGraph` generation.
StreamExecutionEnvironment	The StreamExecutionEnvironment is the context in which a streaming program is executed.
StreamExecutionEnvironmentFactory	Factory class for stream execution environments.
StreamFilter<IN>	A `StreamOperator` for executing `FilterFunctions`.
StreamFlatMap<IN,OUT>	A `StreamOperator` for executing `FlatMapFunctions`.
StreamGraph	Class representing the streaming topology.
StreamGraphContext	Defines a context for optimizing and working with a read-only view of a StreamGraph.
StreamGraphContext.StreamGraphUpdateListener	Interface for observers that monitor the status of a StreamGraph.
StreamGraphGenerator	A generator that generates a `StreamGraph` from a graph of `Transformation`s.
StreamGraphHasher	Interface for different implementations of generating hashes over a stream graph.
StreamGraphHasherV2	StreamGraphHasher from Flink 1.2.
StreamGraphOptimizationStrategy	Defines an optimization strategy for StreamGraph.
StreamGraphOptimizer	The `StreamGraphOptimizer` class is responsible for optimizing a StreamGraph based on runtime information.
StreamGraphUserHashHasher	StreamGraphHasher that works with user provided hashes.
StreamGraphUtils	Utility class that contains helper methods to generating `StreamGraph`.
StreamGroupedReduceAsyncStateOperator<IN>	A `StreamOperator` for executing a `ReduceFunction` on a `KeyedStream`.
StreamGroupedReduceOperator<IN>	A `StreamOperator` for executing a `ReduceFunction` on a `KeyedStream`.
StreamingFunctionUtils	Utility class that contains helper methods to work with Flink Streaming `Functions`.
StreamingJobGraphGenerator	The StreamingJobGraphGenerator converts a `StreamGraph` into a `JobGraph`.
StreamingRuntimeContext	Implementation of the `RuntimeContext`, for streaming operators.
StreamInputProcessor	Interface for processing records by `StreamTask`.
StreamIterationHead<OUT>	A special `StreamTask` that is used for executing feedback edges.
StreamIterationTail<IN>	A special `StreamTask` that is used for executing feedback edges.
StreamMap<IN,OUT>	A `StreamOperator` for executing `MapFunctions`.
StreamMultipleInputProcessor	Input processor for `MultipleInputStreamOperator`.
StreamMultipleInputProcessorFactory	A factory for `StreamMultipleInputProcessor`.
StreamNode	Class representing the operators in the streaming programs, with all their properties.
StreamNodeForwardGroup	Stream node level implement for `ForwardGroup`.
StreamNodeUpdateRequestInfo	Helper class carries the data required to updates a stream edge.
StreamOneInputProcessor<IN>	Input reader for `OneInputStreamTask`.
StreamOperator<OUT>	Basic interface for stream operators.
StreamOperatorFactory<OUT>	A factory to create `StreamOperator`.
StreamOperatorFactoryUtil	A utility to instantiate new operators with a given factory.
StreamOperatorParameters<OUT>	Helper class to construct `AbstractStreamOperatorV2`.
StreamOperatorStateContext	This interface represents a context from which a stream operator can initialize everything connected to state such as e.g. backends, raw state, and timer service manager.
StreamOperatorStateHandler	Class encapsulating various state backend handling logic for `StreamOperator` implementations.
StreamOperatorStateHandler.CheckpointedStreamOperator	Custom state handling hooks to be invoked by `StreamOperatorStateHandler`.
StreamOperatorUtils
StreamOperatorWrapper<OUT,OP extends StreamOperator<OUT>>	This class handles the finish, endInput and other related logic of a `StreamOperator`.
StreamPartitioner<T>	A special `ChannelSelector` for use in streaming programs.
StreamProject<IN,OUT extends org.apache.flink.api.java.tuple.Tuple>	A `StreamOperator` for executing projections on streams.
StreamProjection<IN>	The result of `DataStream.project(int...)`.
StreamRecord<T>	One value in a data stream.
StreamSink<IN>	A `StreamOperator` for executing `SinkFunctions`.
StreamSource<OUT,SRC extends SourceFunction<OUT>>	Deprecated. This class is based on the `SourceFunction` API, which is due to be removed.
StreamSourceContexts	Deprecated. This class is based on the `SourceFunction` API, which is due to be removed.
StreamStateHandle	A `StateObject` that represents state that was written to a stream.
StreamTask<OUT,OP extends StreamOperator<OUT>>	Base class for all streaming tasks.
StreamTask.CanEmitBatchOfRecordsChecker	Check whether records can be emitted in batch.
StreamTaskActionExecutor	Executes `Runnable`, `ThrowingRunnable`, or `Callable`.
StreamTaskActionExecutor.SynchronizedStreamTaskActionExecutor	Deprecated. this class should only be used in `SourceStreamTask` which exposes the checkpoint lock as part of Public API.
StreamTaskCancellationContext	Context on the `StreamTask` for figuring out whether it has been cancelled.
StreamTaskException	An exception that is thrown by the stream vertices when encountering an illegal condition.
StreamTaskExternallyInducedSourceInput<T>	A subclass of `StreamTaskSourceInput` for `ExternallyInducedSourceReader`.
StreamTaskFinishedOnRestoreSourceInput<T>	A special source input implementation that immediately emit END_OF_INPUT.
StreamTaskInput<T>	Basic interface for inputs of stream operators.
StreamTaskNetworkInput<T>	Implementation of `StreamTaskInput` that wraps an input from network taken from `CheckpointedInputGate`.
StreamTaskNetworkInputFactory	Factory for `StreamTaskNetworkInput` and `RescalingStreamTaskNetworkInput`.
StreamTaskSourceInput<T>	Implementation of `StreamTaskInput` that reads data from the `SourceOperator` and returns the `DataInputStatus` to indicate whether the source state is available, unavailable or finished.
StreamTaskStateInitializer	This is the interface through which stream task expose a `StreamOperatorStateContext` to their operators.
StreamTaskStateInitializerImpl	This class is the main implementation of a `StreamTaskStateInitializer`.
StreamTaskStateInitializerImpl.KeyedStateBackendCreator<K,R extends org.apache.flink.util.Disposable & Closeable>	Functional interface to create the keyed state backend.
StreamTwoInputProcessorFactory	A factory to create `StreamMultipleInputProcessor` for two input case.
StringifiedAccumulatorResult	Container class that transports the result of an accumulator as set of strings.
StringResourceVersion	`ResourceVersion` implementation with `String` value.
StronglyConnectedComponentsComputeUtils	Utility for computing strongly connected components.
SubpartitionSelector<T>	`SubpartitionSelector` helps to choose from multiple available subpartitions when their output buffers should union into one stream.
SubpartitionSlice	Helper class that describes the statistics of all subpartitions with a specific index within the given partition range.
SubtaskAttemptMessageParameters	The type Subtask attempt message parameters.
SubtaskAttemptNumberStore	Contains the attempt number per subtask.
SubtaskAttemptPathParameter	Path parameter identifying subtask attempt.
SubtaskCheckpointCoordinator	Coordinates checkpointing-related work for a subtask (i.e.
SubtaskCheckpointStatistics	Checkpoint statistics for a subtask.
SubtaskCheckpointStatistics.CompletedSubtaskCheckpointStatistics	Checkpoint statistics for a completed subtask checkpoint.
SubtaskCheckpointStatistics.CompletedSubtaskCheckpointStatistics.CheckpointAlignment	Alignment statistics of the checkpoint.
SubtaskCheckpointStatistics.CompletedSubtaskCheckpointStatistics.CheckpointDuration	Duration of the checkpoint.
SubtaskCheckpointStatistics.PendingSubtaskCheckpointStatistics	Checkpoint statistics for a pending subtask checkpoint.
SubtaskConnectionDescriptor	An event that is used to (de)multiplex old channels over the same new channel.
SubtaskCurrentAttemptDetailsHandler	Request handler providing details about a single task execution attempt.
SubtaskCurrentAttemptDetailsHeaders	Message headers for the `SubtaskCurrentAttemptDetailsHandler`.
SubtaskExecutionAttemptAccumulatorsHandler	Request handler for the subtask execution attempt accumulators.
SubtaskExecutionAttemptAccumulatorsHeaders	Message headers for the `SubtaskExecutionAttemptAccumulatorsHandler`.
SubtaskExecutionAttemptAccumulatorsInfo	Response type of the `SubtaskExecutionAttemptAccumulatorsHandler`.
SubtaskExecutionAttemptDetailsHandler	Handler of specific sub task execution attempt.
SubtaskExecutionAttemptDetailsHeaders	Message headers for the `SubtaskExecutionAttemptDetailsHandler`.
SubtaskExecutionAttemptDetailsInfo	The sub task execution attempt response.
SubtaskFileMergingManagerRestoreOperation	Restore operation that restores file-merging information belonging to one subtask for `FileMergingSnapshotManager`.
SubtaskIndexPathParameter	Path parameter specifying the index of a subtask.
SubtaskIndexQueryParameter	Query parameter specifying the index of a subtask.
SubTaskInitializationMetrics	A collection of simple metrics, around the triggering of a checkpoint.
SubTaskInitializationMetricsBuilder	A builder for `SubTaskInitializationMetrics`.
SubtaskMessageParameters	Message parameters for subtask REST handlers.
SubtaskMetricsHandler	Handler that returns subtask metrics.
SubtaskMetricsHeaders	`MessageHeaders` for `SubtaskMetricsHandler`.
SubtaskMetricsMessageParameters	`MessageParameters` for `SubtaskMetricsHandler`.
SubtasksAllAccumulatorsHandler	Request handler for the subtasks all accumulators.
SubtasksAllAccumulatorsHeaders	Message headers for the `SubtasksAllAccumulatorsHandler`.
SubtasksAllAccumulatorsInfo	Response type of the `SubtasksAllAccumulatorsHandler`.
SubtasksAllAccumulatorsInfo.SubtaskAccumulatorsInfo	Detailed information about subtask accumulators.
SubtasksFilterQueryParameter	`MessageQueryParameter` for selecting subtasks when aggregating metrics.
SubtaskState	Deprecated. Internal class for savepoint backwards compatibility.
SubtaskStateMapper	The `SubtaskStateMapper` narrows down the subtasks that need to be read during rescaling to recover from a particular subtask when in-flight data has been stored in the checkpoint.
SubtaskStateStats	Statistics for a single subtask that is part of a checkpoint.
SubtasksTimesHandler	Request handler for the subtasks times info.
SubtasksTimesHeaders	Message headers for the `SubtasksTimesHandler`.
SubtasksTimesInfo	Response type of the `SubtasksTimesHandler`.
SubtasksTimesInfo.SubtaskTimeInfo	Nested class to encapsulate the sub task times info.
SumAggregator<T>	An `AggregationFunction` that sums up fields.
SumFunction	Internal function for summing up contents of fields.
SuperstepBarrier	A resettable one-shot latch.
SuperstepKickoffLatch	Latch used to wait for the previous superstep to complete.
SuperstepKickoffLatchBroker	`Broker` for `SuperstepKickoffLatch`.
SupportsPostCommitTopology<CommittableT>	Allows expert users to implement a custom topology after `Committer`.
SupportsPreCommitTopology<WriterResultT,CommittableT>	Allows expert users to implement a custom topology after `SinkWriter` and before `Committer`.
SupportsPreWriteTopology<InputT>	Allows expert users to implement a custom topology before `SinkWriter`.
SuppressRestartsException	Exception thrown in order to suppress job restarts.
SyncEventHandler	Listener for `WorkerDoneEvent` which also aggregates all aggregators from iteration tasks and signals the end of the superstep.
SynchronousBufferFileReader	A synchronous `BufferFileReader` implementation.
SynchronousChainedCombineDriver<IN,OUT>	The chained variant of the combine driver which is also implemented in GroupReduceCombineDriver.
SynchronousFileIOChannel	A base class for synchronous readers and writers.
SyncIteratorWrapper<T>
SyncPreferredLocationsRetriever	Component to retrieve the preferred locations of an execution vertex.
SystemOutRedirectionUtils	Utility class for redirect the `System.out` and `System.err`.
SystemProcessingTimeService	A `TimerService` which assigns as current processing time the result of calling `System.currentTimeMillis()` and registers timers using a `ScheduledThreadPoolExecutor`.
SystemResourcesCounter	Daemon thread probing system resources.
SystemResourcesMetricsInitializer	Utility class to initialize system resource metrics.
Task	The Task represents one execution of a parallel subtask on a TaskManager.
Task.NotifyCheckpointOperation	Various operation of notify checkpoint.
TaskActions	Actions which can be performed on a `Task`.
TaskBackPressureResponse	Response to the task back pressure request rpc call.
TaskCheckpointMessageParameters	Message parameters for subtask related checkpoint message.
TaskCheckpointStatisticDetailsHandler	REST handler which serves checkpoint statistics for subtasks.
TaskCheckpointStatistics	Checkpoint statistics for a single task.
TaskCheckpointStatisticsHeaders	Headers for the `TaskCheckpointStatisticDetailsHandler`.
TaskCheckpointStatisticsWithSubtaskDetails	Task checkpoint statistics which also includes information about the sub task checkpoint statistics.
TaskCheckpointStatisticsWithSubtaskDetails.CheckpointAlignment	Alignment information for a specific checkpoint at a given task.
TaskCheckpointStatisticsWithSubtaskDetails.CheckpointDuration	Duration of a checkpoint split up into its synchronous and asynchronous part.
TaskCheckpointStatisticsWithSubtaskDetails.Summary	Summary of the checkpoint statistics for a given task.
TaskConfig	Configuration class which stores all relevant parameters required to set up the Pact tasks.
TaskContext<S,OT>	The task context gives a driver (e.g., `MapDriver`, or `JoinDriver`) access to the runtime components and configuration that they can use to fulfil their task.
TaskDeploymentDescriptor	A task deployment descriptor contains all the information necessary to deploy a task on a task manager.
TaskDeploymentDescriptor.MaybeOffloaded<T>	Wrapper class for serialized values which may be offloaded to the `BlobServer` or not.
TaskDeploymentDescriptor.NonOffloaded<T>	A serialized value that is not offloaded to the `BlobServer`.
TaskDeploymentDescriptor.Offloaded<T>	Reference to a serialized value that was offloaded to the `BlobServer`.
TaskDeploymentDescriptorFactory	Factory of `TaskDeploymentDescriptor` to deploy `Task` from `Execution`.
TaskDeploymentDescriptorFactory.PartitionLocationConstraint	Defines whether the partition's location must be known at deployment time or can be unknown and, therefore, updated later.
TaskDeploymentDescriptorFactory.ShuffleDescriptorAndIndex	This class represents the shuffle descriptor with it index in `ConsumedPartitionGroup`.
TaskDeploymentDescriptorFactory.ShuffleDescriptorGroup	A set of shuffle descriptors that will be serialized together.
TaskEvent	Subclasses of this event are recognized as custom events that are not part of the core flink runtime.
TaskEventDispatcher	The task event dispatcher dispatches events flowing backwards from a consuming task to the task producing the consumed result.
TaskEventHandler	The event handler manages `EventListener` instances and allows to publish events to them.
TaskEventPublisher	The task event publisher is used for publishing the event to the registered `EventListener` instances.
TaskException	Exception indicating a task related problem on the `TaskExecutor`.
TaskExecutionState	This class represents an update about a task's execution state.
TaskExecutionStateTransition	Wraps `TaskExecutionState`, along with actions to take if it is FAILED state.
TaskExecutor	TaskExecutor implementation.
TaskExecutorBlobService	`BlobService` that gives access to a `JobPermanentBlobService` and allows to set the target blob server address.
TaskExecutorChannelStateExecutorFactoryManager	This class holds the all `ChannelStateWriteRequestExecutorFactory` objects for a task executor (manager).
TaskExecutorClusterPartitionReleaser	Interface for releasing cluster partitions on a task executor.
TaskExecutorConnection	This class is responsible for grouping the TaskExecutorGateway and the InstanceID of a registered task executor.
TaskExecutorFileMergingManager	There is one `FileMergingSnapshotManager` for each job per task manager.
TaskExecutorFlinkMemory	Flink internal memory components of Task Executor.
TaskExecutorFlinkMemoryUtils	`FlinkMemoryUtils` for Task Executor.
TaskExecutorGateway	`TaskExecutor` RPC gateway interface.
TaskExecutorGatewayDecoratorBase	A class that decorates/forwards calls to a `TaskExecutorGateway`.
TaskExecutorHeartbeatPayload	Payload for heartbeats sent from the TaskExecutor to the ResourceManager.
TaskExecutorLocalStateStoresManager	This class holds the all `TaskLocalStateStoreImpl` objects for a task executor (manager).
TaskExecutorMemoryConfiguration	TaskExecutorConfiguration collects the configuration of a TaskExecutor instance.
TaskExecutorOperatorEventGateway	The gateway through which the `OperatorCoordinator` can send an event to an Operator on the Task Manager side.
TaskExecutorPartitionInfo	Encapsulates meta-information the TaskExecutor requires to be kept for each partition.
TaskExecutorPartitionTracker	Utility for tracking partitions.
TaskExecutorPartitionTrackerImpl	Utility for tracking partitions and issuing release calls to task executors and shuffle masters.
TaskExecutorProcessSpec	Describe the specifics of different resource dimensions of the TaskExecutor process.
TaskExecutorProcessSpecBuilder	Builder for `TaskExecutorProcessSpec`.
TaskExecutorProcessUtils	Utility class for TaskExecutor memory configurations.
TaskExecutorRegistration	Information provided by the TaskExecutor when it registers to the ResourceManager.
TaskExecutorRegistrationRejection	Rejection response from the `ResourceManager` for the `TaskExecutor`.
TaskExecutorRegistrationSuccess	Base class for responses from the ResourceManager to a registration attempt by a TaskExecutor.
TaskExecutorResourceSpec	Specification of resources to use in running `TaskExecutor`.
TaskExecutorResourceUtils	Utility class for `TaskExecutorResourceSpec` of running `TaskExecutor`.
TaskExecutorStateChangelogStoragesManager	This class holds the all `StateChangelogStorage` objects for a task executor (manager).
TaskExecutorThreadInfoGateway	RPC gateway for requesting `ThreadInfoSample`.
TaskExecutorToJobManagerHeartbeatPayload	Payload for heartbeats sent from the TaskExecutor to the JobManager.
TaskExecutorToResourceManagerConnection	The connection between a TaskExecutor and the ResourceManager.
TaskExecutorToServiceAdapter	Simple adapter for `TaskExecutor` to adapt to `TaskManagerRunner.TaskExecutorService`.
TaskInformation	Container class for operator/task specific information which are stored at the `ExecutionJobVertex`.
TaskInputsOutputsDescriptor	Describes inputs and outputs information of a task.
TaskInvokable	An invokable part of the task.
TaskIOMetricGroup	Metric group that contains shareable pre-defined IO-related metrics.
TaskIOMetricGroup.SizeSupplier<R>	Supplier for sizes.
TaskKvStateRegistry	A helper for KvState registrations of a single task.
TaskLocalStateStore	Classes that implement this interface serve as a task-manager-level local storage for local checkpointed state.
TaskLocalStateStoreImpl	Main implementation of a `TaskLocalStateStore`.
TaskMailbox	A task mailbox provides read and write access to a mailbox and has a lifecycle of open -> (quiesced) -> closed.
TaskMailbox.MailboxClosedException	Exception thrown when `TaskMailbox` is closed.
TaskMailbox.State	This enum represents the states of the mailbox lifecycle.
TaskMailboxImpl	Implementation of `TaskMailbox` in a `BlockingQueue` fashion and tailored towards our use case with multiple writers and single reader.
TaskManagerActions	Interface for the communication of the `Task` with the `TaskExecutor`.
TaskManagerConfiguration	Configuration object for `TaskExecutor`.
TaskManagerCustomLogHandler	Rest handler which serves the custom file of the `TaskExecutor`.
TaskManagerCustomLogHeaders	Headers for the `TaskManagerCustomLogHandler`.
TaskManagerDetailsHandler	Handler which serves detailed TaskManager information.
TaskManagerDetailsHeaders	Headers for the `TaskManagerDetailsHandler` which serves the TaskManager details.
TaskManagerDetailsInfo	Message containing base information about a `TaskExecutor` and more detailed metrics.
TaskManagerException	Base exception thrown by the `TaskExecutor`.
TaskManagerFileMessageParameters	Parameters for `TaskManagerCustomLogHandler`.
TaskManagerGateway	Task manager gateway interface to communicate with the task manager.
TaskManagerIdPathParameter	TaskManager id path parameter used by TaskManager related handlers.
TaskManagerInfo	Information of a TaskManager needed in `SlotManager`.
TaskManagerInfo	Base class containing information for a `TaskExecutor`.
TaskManagerInfoWithSlots	Contains the base information about a `TaskExecutor` and its allocated slots.
TaskManagerJobMetricGroup	Special `MetricGroup` representing everything belonging to a specific job, running on the TaskManager.
TaskManagerJobScopeFormat	The scope format for the `JobMetricGroup`.
TaskManagerLocation	This class encapsulates the connection information of a TaskManager.
TaskManagerLocation.DefaultHostNameSupplier	This Supplier class could retrieve the FQDN host name of the given InetAddress on demand, extract the pure host name and cache the results for later use.
TaskManagerLocation.HostNameSupplier
TaskManagerLocation.IpOnlyHostNameSupplier	This Supplier class returns the IP address of the given InetAddress directly, therefore no reverse DNS lookup is required.
TaskManagerLocation.ResolutionMode	The DNS resolution mode for TaskManager's IP address.
TaskManagerLogFileHandler	Rest handler which serves the log files from `TaskExecutor`.
TaskManagerLogFileHeaders	Headers for the `TaskManagerLogFileHandler`.
TaskManagerLogListHandler	Handler which serves detailed TaskManager log list information.
TaskManagerLogsHeaders	Headers for the `TaskManagerLogListHandler`.
TaskManagerLogUrlHeaders	Headers for the log url retriever of TaskManager.
TaskManagerMessageParameters	Message parameter for a TaskManager specific handler.
TaskManagerMetricGroup	Special `MetricGroup` representing a TaskManager.
TaskManagerMetricsHandler	Handler that returns TaskManager metrics.
TaskManagerMetricsHeaders	`MessageHeaders` for `TaskManagerMetricsHandler`.
TaskManagerMetricsInfo	Contains information about the TaskManager metrics.
TaskManagerMetricsInfo.GarbageCollectorInfo	Information about the garbage collector metrics.
TaskManagerMetricsMessageParameters	`MessageParameters` for `TaskManagerMetricsHandler`.
TaskManagerProfilingFileHandler	Rest handler which serves the profiling result file of the `TaskExecutor`.
TaskManagerProfilingFileHeaders	Headers for the `TaskManagerProfilingFileHandler`.
TaskManagerProfilingFileMessageParameters	Parameters for `TaskManagerProfilingFileHandler`.
TaskManagerProfilingHandler	Rest handler which serves the profiling service from a `TaskExecutor`.
TaskManagerProfilingHeaders	Headers for the `TaskManagerProfilingHandler`.
TaskManagerProfilingListHandler	Handler which serves detailed TaskManager profiling list information.
TaskManagerProfilingListHeaders	Headers for the `TaskManagerProfilingListHandler`.
TaskManagerRegistrationInformation	DTO for TaskManager registration information.
TaskManagerRunner	This class is the executable entry point for the task manager in yarn or standalone mode.
TaskManagerRunner.Result
TaskManagerRunner.TaskExecutorService
TaskManagerRunner.TaskExecutorServiceFactory	Factory for `TaskExecutor`.
TaskManagerRuntimeInfo	Interface to access `TaskExecutor` information.
TaskManagerScopeFormat	The scope format for the `TaskManagerMetricGroup`.
TaskManagerServices	Container for `TaskExecutor` services such as the `MemoryManager`, `IOManager`, `ShuffleEnvironment`.
TaskManagerServicesConfiguration	Configuration for the task manager services such as the memory manager, the io manager and the metric registry.
TaskManagersFilterQueryParameter	`MessageQueryParameter` for selecting task managers when aggregating metrics.
TaskManagersHandler	Returns an overview over all registered TaskManagers of the cluster.
TaskManagersHeaders	Message headers for the `TaskManagersHandler`.
TaskManagersInfo	Class containing a collection of `TaskManagerInfo`.
TaskManagerSlotInformation	Basic information about a TaskManager slot.
TaskManagerStdoutFileHandler	Rest handler which serves the stdout file of the `TaskExecutor`.
TaskManagerStdoutFileHeaders	Headers for the `TaskManagerStdoutFileHandler`.
TaskManagerThreadDumpHandler	Rest handler which serves the thread dump info from a `TaskExecutor`.
TaskManagerThreadDumpHeaders	Headers for the `TaskManagerThreadDumpHandler`.
TaskMetricGroup	Special `MetricGroup` representing a Flink runtime Task.
TaskNotRunningException	An exception indicating that a target task is not running.
TaskOperatorEventGateway	Gateway to send an `OperatorEvent` or `CoordinationRequest` from a Task to the `OperatorCoordinator` JobManager side.
TaskScopeFormat	The scope format for the `TaskMetricGroup`.
TaskSlot<T extends TaskSlotPayload>	Container for multiple `tasks` belonging to the same slot.
TaskSlotPayload	Payload interface for `TaskSlot`.
TaskSlotTable<T extends TaskSlotPayload>	Container for multiple `TaskSlot` instances.
TaskSlotTableImpl<T extends TaskSlotPayload>	Default implementation of `TaskSlotTable`.
TaskState	Deprecated. Internal class for savepoint backwards compatibility.
TaskStateManager	This interface provides methods to report and retrieve state for a task.
TaskStateManagerImpl	This class is the default implementation of `TaskStateManager` and collaborates with the job manager through `CheckpointResponder`) as well as a task-manager-local state store.
TaskStateSnapshot	This class encapsulates state handles to the snapshots of all operator instances executed within one task.
TaskStateStats	Statistics for a single task/operator that gathers all statistics of its subtasks and provides summary statistics about all subtasks.
TaskStateStats.TaskStateStatsSummary	Summary of the subtask stats of a single task/operator.
TaskStatsRequestCoordinator<T,V>	Encapsulates the common functionality for requesting statistics from tasks and combining their responses.
TaskStatsRequestCoordinator.PendingStatsRequest<T,V>	A pending task stats request, which collects samples from individual tasks and completes the response future upon gathering all of of them.
TaskSubmissionException	Exception indicating a problem with the `Task` submission at the `TaskException`.
TaskThreadInfoResponse	Response to the request to collect thread details samples.
TempBarrier<T>	This class facilitates JVM-local exchange between stages of a batch job.
Terminable	Models the functionality that the termination of an iterative task can be requested from outside.
TerminationEvent	Signals that the iteration is completely executed, participating tasks must terminate now.
TerminationModeQueryParameter	Termination mode query parameter.
TerminationModeQueryParameter.TerminationMode	Termination mode.
TestableKeyedStateBackend<K>	A keyed state backend interface for internal testing purpose.
ThreadDumpInfo	Class containing thread dump information.
ThreadDumpInfo.ThreadInfo	Class containing information about a thread.
ThreadInfoRequestCoordinator	A coordinator for triggering and collecting thread info stats of running job vertex subtasks.
ThreadInfoSample	A serializable wrapper container for transferring parts of the `ThreadInfo`.
ThreadInfoSamplesRequest	A wrapper for parameters of a thread info sampling request.
ThresholdMeter	A timestamp queue based threshold meter.
ThresholdMeter.ThresholdExceedException	Exception thrown when a threshold exceeds.
ThroughputCalculator	Class for measuring the throughput based on incoming data size and measurement period.
ThrowableAnnotation	Annotation to classify subclasses of `Throwable` into categories w.r.t. recovery.
ThrowableClassifier	Helper class, given a exception do the classification.
ThrowableType	Enum for the classification of `Throwable` objects into failure/recovery classes.
ThrowingExecutionPlanWriter	`ExecutionPlanWriter` implementation which does not allow to store `ExecutionPlan`.
ThrowingIterator<E>	Modified `Iterator` interface that lets the implementation throw an `IOException`.
TierConsumerAgent	The `TierConsumerAgent` is the consumer agent of each tier in tiered store, which could read data from responding tier.
TieredInternalShuffleMaster	A wrapper internal shuffle master class for tiered storage.
TieredInternalShuffleMasterSnapshot	The internal `ShuffleMasterSnapshot` for hybrid shuffle.
TieredResultPartition	`TieredResultPartition` appends records and events to the tiered storage, which supports the upstream dynamically switches storage tier for writing shuffle data, and the downstream will read data from the relevant tier.
TieredResultPartitionFactory	`TieredResultPartitionFactory` contains the components to set up tiered storage.
TieredShuffleMasterSnapshot	This class represents a snapshot of tiered shuffle master, which can be used to restore the internal state of the shuffle master.
TieredStorageBytesBasedDataIdentifier	The bytes based unique identification for the Tiered Storage.
TieredStorageConfiguration	Configurations for the Tiered Storage.
TieredStorageConsumerClient	`TieredStorageConsumerClient` is used to read buffer from tiered store.
TieredStorageConsumerSpec	Describe the different data sources in `TieredStorageConsumerClient`.
TieredStorageDataIdentifier	Identifier interface in the Tiered Storage.
TieredStorageIdMappingUtils	Utils to convert the Ids to Tiered Storage Ids, or vice versa.
TieredStorageInputChannelId	Identifier of an InputChannel.
TieredStorageMasterClient	Client of the Tiered Storage used by the master.
TieredStorageMemoryManager	The `TieredStorageMemoryManager` is to request or recycle buffers from `LocalBufferPool` for different memory owners, for example, the tiers, the buffer accumulator, etc.
TieredStorageMemoryManagerImpl	The implementation for `TieredStorageMemoryManager`.
TieredStorageMemorySpec	The memory specs for a memory owner, including the owner itself, the number of guaranteed buffers of the memory owner, etc.
TieredStorageNettyService	`TieredStorageNettyService` is used to create writers and readers to netty.
TieredStorageNettyServiceImpl	The default implementation of `TieredStorageNettyService`.
TieredStoragePartitionId	Identifier of a partition.
TieredStorageProducerClient	Client of the Tiered Storage used by the producer.
TieredStorageProducerMetricUpdate	The metric statistics for the tiered storage producer.
TieredStorageResource	The resource (e.g., local files, remote storage files, etc.) for the Tiered Storage.
TieredStorageResourceRegistry	A registry that maintains local or remote resources that correspond to a certain set of data in the Tiered Storage.
TieredStorageResultSubpartitionView	The `TieredStorageResultSubpartitionView` is the implementation of `ResultSubpartitionView` of `TieredResultPartition`.
TieredStorageSortBuffer	When getting buffers, The `SortBasedDataBuffer` need not recycle the read target buffer..
TieredStorageSubpartitionId	Identifier of a subpartition.
TieredStorageTopicId	Identifier of a topic.
TieredStorageUtils	Utils for reading from or writing to tiered storage.
TierFactory	A factory that creates all the components of a tier.
TierFactoryInitializer	A class responsible for initializing and returning a list of `TierFactory` instances based on the provided `TieredStorageConfiguration`.
TierMasterAgent	The master-side agent of a Tier.
TierProducerAgent	The producer-side agent of a Tier.
TierShuffleDescriptor	The `TierShuffleDescriptor` interface is the shuffle descriptor for a single tier.
TierShuffleHandler	A handler to process the call back result from each tier, the callbacks can be some events, some errors, some exceptions, etc.
TimeDomain	`TimeDomain` specifies whether a firing timer is based on event time or processing time.
TimeoutListener<K>	Listener for timeout events by the `TimerService`.
TimerException	`RuntimeException` for wrapping exceptions that are thrown in the timer callback of the timer service in `StreamTask`.
TimerGauge	`TimerGauge` measures how much time is spent in a given state, with entry into that state being signaled by `TimerGauge.markStart()`.
TimerGauge.StartStopListener	Listens for `TimerGauge.markStart()` and `TimerGauge.markEnd()` events.
TimerHeapInternalTimer<K,N>	Implementation of `InternalTimer` to use with a `HeapPriorityQueueSet`.
TimerSerializer<K,N>	A serializer for `TimerHeapInternalTimer` objects that produces a serialization format that is lexicographically aligned the priority of the timers.
TimerSerializerSnapshot<K,N>	Snapshot class for the `TimerSerializer`.
TimerService<K>	Service to register timeouts for a given key.
TimerService	Interface for working with time and timers.
TimerService	A common timer service interface with life cycle methods.
TimestampedCollector<T>	Wrapper around an `Output` for user functions that expect a `Output`.
TimestampedCollectorWithDeclaredVariable<T>	Wrapper around an `Output` for user functions that expect a `Output`.
TimestampedFileInputSplit	A `FileInputSplit` with `TimestampedInputSplit`.
TimestampedInputSplit	An extended `InputSplit` that also includes information about: The modification time of the file this split belongs to.
TimestampedValue<T>	Stores the value and the timestamp of the record.
TimestampsAndWatermarks<T>	Basic interface for the timestamp extraction and watermark generation logic for the `SourceReader`.
TimestampsAndWatermarks.TimestampsAndWatermarksContextProvider
TimestampsAndWatermarks.WatermarkUpdateListener	Lets the owner/creator of the output know about latest emitted watermark.
TimestampsAndWatermarksContext	A simple implementation of a context that is both `TimestampAssignerSupplier.Context` and `WatermarkGeneratorSupplier.Context`.
TimestampsAndWatermarksOperator<T>	A stream operator that may do one or both of the following: extract timestamps from events and generate watermarks.
TimestampsAndWatermarksOperator.WatermarkEmitter	Implementation of the `WatermarkEmitter`, based on the components that are available inside a stream operator.
TimestampsAndWatermarksOperatorFactory<T>	`StreamOperatorFactory` for `TimestampsAndWatermarksOperator`.
TimestampsAndWatermarksTransformation<IN>	A `PhysicalTransformation` for a `DataStream.assignTimestampsAndWatermarks(WatermarkStrategy)`.
TimestampsAndWatermarksTransformationTranslator<IN>	A `TransformationTranslator` for the `TimestampsAndWatermarksTransformation`.
TimeToConsumeGauge	Gauge metric measuring the maximal time to consume all buffers of all input gates.
TimeWindow	A `Window` that represents a time interval from `start` (inclusive) to `end` (exclusive).
TimeWindow.Serializer	The serializer used to write the TimeWindow type.
TimeWindow.Serializer.TimeWindowSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
Topology<VID extends VertexID,RID extends ResultID,V extends Vertex<VID,RID,V,R>,R extends Result<VID,RID,V,R>,PR extends PipelinedRegion<VID,RID,V,R>>	Extends the `BaseTopology` by pipelined regions.
TraceReporterSetup	Encapsulates everything needed for the instantiation and configuration of a `TraceReporter`.
TransformationTranslator<OUT,T extends org.apache.flink.api.dag.Transformation<OUT>>	A `TransformationTranslator` is responsible for translating a given `Transformation` to its runtime implementation depending on the execution mode.
TransformationTranslator.Context	A context giving the necessary information for the translation of a given transformation.
TransformationWithLineage<T>	A `Transformation` that contains lineage information.
TransientBlobCache	Provides access to transient BLOB files stored at the `BlobServer`.
TransientBlobKey	BLOB key referencing transient BLOB files.
TransientBlobService	A service to retrieve transient binary large objects (BLOBs) which are deleted on the `BlobServer` when they are retrieved.
TransportException
Trigger<T,W extends Window>	A `Trigger` determines when a pane of a window should be evaluated to emit the results for that part of the window.
Trigger.OnMergeContext	Extension of `Trigger.TriggerContext` that is given to `Trigger.onMerge(Window, OnMergeContext)`.
Trigger.TriggerContext	A context object that is given to `Trigger` methods to allow them to register timer callbacks and deal with state.
Triggerable<K,N>	Interface for things that can be called by `InternalTimerService`.
TriggerCheckpointFunction	Wrapper interface for functions triggering checkpoints.
TriggerId	Identifies a savepoint trigger request.
TriggerId.TriggerIdDeserializer	JSON deserializer for `TriggerId`.
TriggerId.TriggerIdSerializer	JSON serializer for `TriggerId`.
TriggerIdPathParameter	`MessagePathParameter` for the trigger id of an asynchronous operation.
TriggerResponse	Response to the triggering of an asynchronous operation.
TriggerResult	Result type for trigger methods.
TriggerSavepointFunction	Wrapper interface for functions triggering savepoints.
TriggerSavepointMode	Describes the context of taking a savepoint: Whether it is a savepoint for a running job or whether the job is cancelled, suspended or terminated with a savepoint.
TtlAggregateFunction<IN,ACC,OUT>	This class wraps aggregating function with TTL logic.
TtlAwareSerializer<T>	This class wraps a `TypeSerializer` with ttl awareness.
TtlAwareSerializerSnapshot<T>	A `TypeSerializerSnapshot` for TtlAwareSerializer.
TtlAwareSerializerSnapshotWrapper<T>	Wrap the TypeSerializerSnapshot restored from `StateMetaInfoSnapshot` to TtlAwareSerializerSnapshot
TtlReduceFunction<T>	This class wraps reducing function with TTL logic.
TtlStateContext<T,SV>
TtlStateFactory<K,N,SV,TTLSV,S extends org.apache.flink.api.common.state.State,IS extends S>	This state factory wraps state objects, produced by backends, with TTL logic.
TtlStateFactory<K,N,SV,TTLSV,S extends org.apache.flink.api.common.state.v2.State,IS>
TtlStateFactory.TtlSerializer<T>	Serializer for user state value with TTL.
TtlStateFactory.TtlSerializer<T>	Serializer for user state value with TTL.
TtlStateFactory.TtlSerializerSnapshot<T>	A `TypeSerializerSnapshot` for TtlSerializer.
TtlStateFactory.TtlSerializerSnapshot<T>	A `TypeSerializerSnapshot` for TtlSerializer.
TtlTimeProvider	Provides time to TTL logic to judge about state expiration.
TtlUtils	Common functions related to State TTL.
TtlValue<T>	This class wraps user value of state with TTL.
TumblingEventTimeWindows	A `WindowAssigner` that windows elements into windows based on the timestamp of the elements.
TumblingProcessingTimeWindows	A `WindowAssigner` that windows elements into windows based on the current system time of the machine the operation is running on.
TwoInputStreamOperator<IN1,IN2,OUT>	Interface for stream operators with two inputs.
TwoInputStreamOperatorFactory<IN1,IN2,OUT>	A factory to create `TwoInputStreamOperator`.
TwoInputStreamTask<IN1,IN2,OUT>	A `StreamTask` for executing a `TwoInputStreamOperator` and supporting the `TwoInputStreamOperator` to select input for reading.
TwoInputTransformation<IN1,IN2,OUT>	This Transformation represents the application of a `TwoInputStreamOperator` to two input `Transformations`.
TwoInputTransformationTranslator<IN1,IN2,OUT>	A `TransformationTranslator` for the `TwoInputTransformation`.
UdfStreamOperatorFactory<OUT>	Udf stream operator factory.
UnavailableDispatcherOperationException	Exception indicating that a Dispatcher operation is temporarily unavailable.
UncheckpointedCollectResultBuffer<T>	A buffer which encapsulates the logic of dealing with the response from the `CollectSinkFunction`.
UncompressedStreamCompressionDecorator	This implementation does not decorate the stream with any compression.
UnfulfillableSlotRequestException	Exception denoting that a slot request can not be fulfilled by any slot in the cluster.
UnionInputGate	Input gate wrapper to union the input from multiple input gates.
UnionResultSubpartitionView	A wrapper to union the output from multiple `ResultSubpartitionView`s.
UnionTransformation<T>	This transformation represents a union of several input `Transformations`.
UnionTransformationTranslator<OUT>	A `TransformationTranslator` for the `UnionTransformation`.
UnionWithTempOperator<T>
UnknownKvStateLocation	Thrown if there is no `KvStateLocation` found for the requested registration name.
UnknownOperationKeyException	Exception that indicates that there is no ongoing or completed savepoint for a given `JobID` and `TriggerId` pair.
UnknownShuffleDescriptor	Unknown `ShuffleDescriptor` for which the producer has not been deployed yet.
UnknownTaskExecutorException	Exception denoting that a requested `TaskExecutor` could not be found.
UnknownTierShuffleDescriptor	This is a placeholder when the tier shuffle descriptor should be unknown because the netty shuffle descriptor is unknown.
UnregisteredJobManagerJobMetricGroupFactory	`JobManagerJobMetricGroupFactory` which returns an unregistered `JobManagerJobMetricGroup`.
UnregisteredMetricGroups	A collection of safe drop-in replacements for existing `ComponentMetricGroup`s.
UnregisteredMetricGroups.UnregisteredJobManagerJobMetricGroup	A safe drop-in replacement for `JobManagerJobMetricGroup`s.
UnregisteredMetricGroups.UnregisteredJobManagerMetricGroup	A safe drop-in replacement for `JobManagerMetricGroup`s.
UnregisteredMetricGroups.UnregisteredJobMangerOperatorMetricGroup	A safe drop-in replacement for `JobManagerOperatorMetricGroup`s.
UnregisteredMetricGroups.UnregisteredOperatorMetricGroup	A safe drop-in replacement for `InternalOperatorMetricGroup`s.
UnregisteredMetricGroups.UnregisteredProcessMetricGroup	A safe drop-in replacement for `ProcessMetricGroups`.
UnregisteredMetricGroups.UnregisteredResourceManagerMetricGroup	A safe drop-in replacement for `ResourceManagerMetricGroups`.
UnregisteredMetricGroups.UnregisteredSlotManagerMetricGroup	A safe drop-in replacement for `SlotManagerMetricGroups`.
UnregisteredMetricGroups.UnregisteredTaskManagerJobMetricGroup	A safe drop-in replacement for `TaskManagerJobMetricGroup`s.
UnregisteredMetricGroups.UnregisteredTaskManagerMetricGroup	A safe drop-in replacement for `TaskManagerMetricGroup`s.
UnregisteredMetricGroups.UnregisteredTaskMetricGroup	A safe drop-in replacement for `TaskMetricGroup`s.
UnresolvedTaskManagerLocation	This class encapsulates the connection information of a TaskManager, without resolving the hostname.
UnsupportedOperationExecutor	`Executor` implementation which fails when `UnsupportedOperationExecutor.execute(Runnable)` is called.
UnsupportedTimeCharacteristicException	An exception that indicates that a time characteristic was used that is not supported in the current operation.
UntypedResponseMessageHeaders<R extends RequestBody,M extends MessageParameters>	Message headers for a web handler request.
UpdateSchedulerNgOnInternalFailuresListener	Calls `SchedulerNG.updateTaskExecutionState(TaskExecutionStateTransition)` on task failure.
UpperLimitExceptionParameter	Specifies the upper limit of exceptions to return for JobExceptionsHandler.
UpstreamRecoveryTracker	Tracks status of upstream channels while they recover.
UpTimeGauge	A gauge that returns (in milliseconds) how long a job has been running.
UserAccumulator	User accumulator info.
UserFunctionProvider<F extends org.apache.flink.api.common.functions.Function>	The interface with user function.
ValueStateAdaptor<K,N,V>	An adaptor that transforms `InternalValueState` into `InternalValueState`.
VariableLengthByteKeyAndValueComparator<INPUT>	The `VariableLengthByteKeyAndValueComparator` is used by `KeyedSortPartitionOperator` to compare records according to both the record key and record value.
Vertex<VID extends VertexID,RID extends ResultID,V extends Vertex<VID,RID,V,R>,R extends Result<VID,RID,V,R>>	Represents a logical or execution task.
VertexAttemptNumberStore	Contains the attempt numbers per vertex.
VertexEndOfDataListener	Records the end of data event of each task, and allows for checking whether all tasks of a `JobGraph` have reached the end of data.
VertexFinishedStateChecker	This class encapsulates the operation that checks if there are illegal modification to the JobGraph when restoring from a checkpoint with partially or fully finished operator states.
VertexFlameGraph	Flame Graph representation for a job vertex or an execution vertex.
VertexFlameGraph.Node	Graph node.
VertexFlameGraphFactory	Factory class for creating Flame Graph representations.
VertexGroupComputeUtil	Common utils for processing vertex groups.
VertexID	ID of a `Vertex`.
VertexInputInfoComputationUtils	Util to compute `JobVertexInputInfo`s for execution job vertex.
VertexInputInfoStore	A store contains all the `JobVertexInputInfo`s.
VertexParallelism	Core result of `SlotAllocator.determineParallelism(JobInformation, Collection)` among with `slotAssignments`, describing the parallelism each vertex could be scheduled with.
VertexParallelismAndInputInfosDecider	`VertexParallelismAndInputInfosDecider` is responsible for deciding the parallelism and `JobVertexInputInfo`s of a job vertex, based on the information of the consumed blocking results.
VertexParallelismAndInputInfosDeciderUtils	Utils class for VertexParallelismAndInputInfosDecider.
VertexParallelismInformation	Manages the parallelism properties for a vertex in the execution graph, as well as how they can change during runtime.
VertexParallelismStore	Contains the max parallelism per vertex, along with metadata about how these maxes were calculated.
VertexStatsTracker<T extends Statistics>	Interface for a tracker of statistics for `AccessExecutionJobVertex`.
VertexThreadInfoStats	Thread info statistics of single JobVertex or ExecutionVertex.
VertexThreadInfoTracker	Tracker of thread infos for `ExecutionJobVertex`.
VertexThreadInfoTrackerBuilder	Builder for `VertexThreadInfoTracker`.
VertexwiseSchedulingStrategy	`SchedulingStrategy` instance which schedules tasks in granularity of vertex (which indicates this strategy only supports batch jobs).
VertexwiseSchedulingStrategy.Factory	The factory for creating `VertexwiseSchedulingStrategy`.
ViewUpdater	The ViewUpdater is responsible for updating all metrics that implement the `View` interface.
VoidBlobStore	A blob store doing nothing.
VoidBlobWriter	BlobWriter which does not support writing BLOBs to a store.
VoidHistoryServerArchivist	No-op implementation of the `HistoryServerArchivist`.
VoidMetricFetcher	No-op implementation of the `MetricFetcher`.
VoidNamespace	Singleton placeholder class for state without a namespace.
VoidNamespaceSerializer	Serializer for `VoidNamespace`.
VoidNamespaceSerializer.VoidNamespaceSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
VoidNamespaceTypeInfo	`TypeInformation` for `VoidNamespace`.
Watermark	A Watermark tells operators that no elements with a timestamp older or equal to the watermark timestamp should arrive at the operator.
WatermarkAlignmentEvent	Signals source operators the maximum watermark that emitted records can have.
WatermarkCombiner	A class used to combine `Watermark`s.
WatermarkEvent	This event wraps the `Watermark`, it is used in propagate `Watermark` between shuffle components, and should not be visible to operators and functions.
WatermarkGauge	A `Gauge` for exposing the current input/output watermark.
WatermarkGaugeExposingOutput<T>	An `Output` that measures the last emitted watermark with a `WatermarkGauge`.
WatermarkStatus	A Watermark Status element informs stream tasks whether or not they should continue to expect watermarks from the input stream that sent them.
WatermarkStrategyWithPeriodicWatermarks<T>	The `WatermarkStrategyWithPeriodicWatermarks` assigns event time timestamps to elements, and generates low watermarks that signal event time progress within the stream.
WatermarkStrategyWithPunctuatedWatermarks<T>	The `AssignerWithPunctuatedWatermarks` assigns event time timestamps to elements, and generates low watermarks that signal event time progress within the stream.
WatermarkToDataOutput	An adapter that exposes a `WatermarkOutput` based on a `PushingAsyncDataInput.DataOutput`.
WatermarkUtils	Utils class for `Watermark`.
WebContentHandlerSpecification	Rest handler specification for the web content handler.
WebMonitorEndpoint<T extends RestfulGateway>	Rest endpoint which serves the web frontend REST calls.
WebMonitorExtension	Interface for `WebMonitorEndpoint` extensions.
WebMonitorExtension.EmptyWebMonitorExtension	Empty web monitor extension which can be used as a null object.
WebMonitorUtils	Utilities for the web runtime monitor.
WebMonitorUtils.LogFileLocation	Singleton to hold the log file, the stdout file, the log directory.
Window	A `Window` is a grouping of elements into finite buckets.
WindowAssigner<T,W extends Window>	A `WindowAssigner` assigns zero or more `Windows` to an element.
WindowAssigner.WindowAssignerContext	A context provided to the `WindowAssigner` that allows it to query the current processing time.
WindowedStream<T,K,W extends Window>	A `WindowedStream` represents a data stream where elements are grouped by key, and for each key, the stream of elements is split into windows based on a `WindowAssigner`.
WindowFunction<IN,OUT,KEY,W extends Window>	Base interface for functions that are evaluated over keyed (grouped) windows.
WindowOperator<K,IN,ACC,OUT,W extends Window>	An operator that implements the logic for windowing based on a `WindowAssigner` and `Trigger`.
WindowOperator.Timer<K,W extends Window>	Internal class for keeping track of in-flight timers.
WindowOperatorBuilder<T,K,W extends Window>	A builder for creating `WindowOperators`.
WindowOperatorFactory<K,IN,ACC,OUT,W extends Window>	`StreamOperatorFactory` for `WindowOperator`.
WindowStagger	A `WindowStagger` staggers offset in runtime for each window assignment.
WithBoundedness	An interface to be implemented by transformations that have explicitly set `Boundedness`.
WithinCheckpointFileMergingSnapshotManager	A `FileMergingSnapshotManager` that merging files within a checkpoint.
WithMasterCheckpointHook<E>	This interface can be implemented by streaming functions that need to trigger a "global action" on the master (in the checkpoint coordinator) as part of every checkpoint and restore operation.
WorkerDoneEvent	Completion event sent from each `IterationHead` to the `IterationSynchronizationSinkTask`.
WorkerRegistration<WorkerType extends ResourceIDRetrievable>	This class extends the `TaskExecutorConnection`, adding the worker information.
WorkerResourceSpec	Resource specification of a worker, mainly used by SlotManager requesting from ResourceManager.
WorkerResourceSpec.Builder	Builder for `WorkerResourceSpec`.
WorkerResourceSpecFactory	Factory for creating deployment specific default `WorkerResourceSpec`.
WorkingDirectory	Class that manages a working directory for a process/instance.
WorksetEmptyConvergenceCriterion	A workset iteration is by definition converged if no records have been updated in the solutionset.
WorksetUpdateOutputCollector<T>	A `Collector` to update the iteration workset (partial solution for bulk iterations).
YarnCancelJobTerminationHeaders	Deprecated. This should be removed once we can send arbitrary REST calls via the Yarn proxy.
YarnStopJobTerminationHeaders	Deprecated. This should be removed once we can send arbitrary REST calls via the Yarn proxy.
YieldingOperator<OUT>	A V1 operator that needs access to the `MailboxExecutor` should implement this interface.
YieldingOperatorFactory<OUT>	Deprecated.
ZooKeeperCheckpointIDCounter	`CheckpointIDCounter` instances for JobManagers running in `HighAvailabilityMode.ZOOKEEPER`.
ZooKeeperCheckpointRecoveryFactory	`CheckpointCoordinator` components in `HighAvailabilityMode.ZOOKEEPER`.
ZooKeeperCheckpointStoreUtil	Singleton `CheckpointStoreUtil` implementation for ZooKeeper.
ZooKeeperClientHAServices	ZooKeeper based implementation for `ClientHighAvailabilityServices`.
ZooKeeperExecutionPlanStoreUtil	Singleton `ExecutionPlanStoreUtil` implementation for ZooKeeper.
ZooKeeperExecutionPlanStoreWatcher	`ExecutionPlanStoreWatcher` implementation for ZooKeeper.
ZooKeeperLeaderElectionDriver	ZooKeeper based `LeaderElectionDriver` implementation.
ZooKeeperLeaderElectionDriverFactory	Factory for `ZooKeeperLeaderElectionDriver`.
ZooKeeperLeaderElectionHaServices	ZooKeeper HA services that only use a single leader election per process.
ZooKeeperLeaderRetrievalDriver	The counterpart to the `ZooKeeperLeaderElectionDriver`.
ZooKeeperLeaderRetrievalDriver.LeaderInformationClearancePolicy	Policy when to clear the leader information and to notify the listener about it.
ZooKeeperLeaderRetrievalDriverFactory	`LeaderRetrievalDriverFactory` implementation for Zookeeper.
ZooKeeperModule	Responsible for installing a process-wide ZooKeeper security configuration.
ZookeeperModuleFactory	A `SecurityModuleFactory` for `ZooKeeperModule`.
ZooKeeperSharedCount	Wrapper class for a `SharedCount` so that we don't expose a curator dependency in our internal APIs.
ZooKeeperSharedValue	Wrapper class for a `SharedValue` so that we don't expose a curator dependency in our internal APIs.
ZooKeeperStateHandleStore<T extends Serializable>	Class which stores state via the provided `RetrievableStateStorageHelper` and writes the returned state handle to ZooKeeper.
ZooKeeperUtils	Class containing helper functions to interact with ZooKeeper.
ZooKeeperUtils.SecureAclProvider	Secure `ACLProvider` implementation.
ZooKeeperUtils.ZkClientACLMode	ZooKeeper client ACL mode enum.
ZooKeeperVersionedValue<T>	Wrapper class for a `VersionedValue` so that we don't expose a curator dependency in our internal APIs.