All Classes (Flink : Core 1.18.1-cp1 API)

All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
Class	Description
AbstractAutoCloseableRegistry<R extends AutoCloseable,C extends R,T,E extends Exception>	This is the abstract base class for registries that allow to register instances of `Closeable`, which are all closed if this registry is closed.
AbstractDeserializationSchema<T>	The deserialization schema describes how to turn the byte messages delivered by certain data sources (for example Apache Kafka) into data types (Java/Scala objects) that are processed by Flink.
AbstractID	A statistically unique identification number.
AbstractRichFunction	An abstract stub implementation for rich user-defined functions.
AbstractRuntimeUDFContext	A standalone implementation of the `RuntimeContext`, created by runtime UDF operators.
AbstractUdfOperator<OUT,FT extends Function>	Abstract superclass for all contracts that represent actual operators.
Accumulator<V,R extends Serializable>	Accumulators collect distributed statistics or aggregates in a from user functions and operators.
AccumulatorHelper	Helper functions for the interaction with `Accumulator`.
AggregateFunction<IN,ACC,OUT>	The `AggregateFunction` is a flexible aggregation function, characterized by the following features: The aggregates may use different types for input values, intermediate aggregates, and result type, to support a wide range of aggregation types.
AggregatingState<IN,OUT>	`State` interface for aggregating state, based on an `AggregateFunction`.
AggregatingStateDescriptor<IN,ACC,OUT>	A StateDescriptor for `AggregatingState`.
Aggregator<T extends Value>	Aggregators are a means of aggregating values across parallel instances of a function.
AggregatorRegistry	A registry for iteration `Aggregator`s.
AggregatorWithName<T extends Value>	Simple utility class holding an `Aggregator` with the name it is registered under.
AkkaOptions	Akka configuration options.
AlgorithmOptions	Configuration parameters for join/sort algorithms.
AppendingState<IN,OUT>	Base interface for partitioned state that supports adding elements and inspecting the current state.
Archiveable<T extends Serializable>
ArchivedExecutionConfig	Serializable class which is created when archiving the job.
ArrayUtils	Utility class for Java arrays.
AscendingTimestampsWatermarks<T>	A watermark generator that assumes monotonically ascending timestamps within the stream split and periodically generates watermarks based on that assumption.
AtomicType<T>	An atomic type is a type that is treated as one indivisible unit and where the entire type acts as a key.
AutoCloseableAsync	Closeable interface which allows to close a resource in a non blocking fashion.
AutoCloseableRegistry	This class allows to register instances of `AutoCloseable`, which are all closed if this registry is closed.
AverageAccumulator	An accumulator that computes the average value.
AvroUtils	Utility methods for dealing with Avro types.
BackPressuringExecutor	An executor decorator that allows only a certain number of concurrent executions.
BaseStatistics	Interface describing the basic statistics that can be obtained from the input.
BasicArrayTypeInfo<T,C>	Type information for arrays boxed primitive types.
BasicTypeComparator<T extends Comparable<T>>
BasicTypeInfo<T>	Type information for primitive types (int, long, double, byte, ...), String, Date, Void, BigInteger, and BigDecimal.
BatchExecutionOptions	Configuration options for the batch job execution.
BatchShuffleMode	Defines how data is exchanged between tasks in batch `ExecutionOptions.RUNTIME_MODE` if the shuffling behavior has not been set explicitly for an individual exchange.
BiConsumerWithException<T,U,E extends Throwable>	A checked extension of the `BiConsumer` interface.
BiFunctionWithException<T,U,R,E extends Throwable>	`BiFunction` interface which can throw exceptions.
BigDecComparator	Comparator for comparing BigDecimal values.
BigDecParser	Parses a text field into a `BigDecimal`.
BigDecSerializer	Serializer for serializing/deserializing BigDecimal values including null values.
BigDecSerializer.BigDecSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
BigIntComparator	Comparator for comparing BigInteger values.
BigIntParser	Parses a text field into a `BigInteger`.
BigIntSerializer	Serializer for serializing/deserializing BigInteger values including null values.
BigIntSerializer.BigIntSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
BinaryInputFormat<T>	Base class for all input formats that use blocks of fixed size.
BinaryOperatorInformation<IN1,IN2,OUT>	A class for holding information about a single input operator, such as input/output TypeInformation.
BinaryOutputFormat<T>
BlobServerOptions	Configuration options for the BlobServer and BlobCache.
BlockElement	Part of description that represents a block e.g.
BlockInfo	A block of 24 bytes written at the end of a block in a binary file, and containing i) the number of records in the block, ii) the accumulated number of records, and iii) the offset of the first record in the block.
BlockLocation	A BlockLocation lists hosts, offset and length of block.
BooleanComparator
BooleanParser
BooleanPrimitiveArrayComparator
BooleanPrimitiveArraySerializer	A serializer for boolean arrays.
BooleanPrimitiveArraySerializer.BooleanPrimitiveArraySerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
BooleanSerializer	Type serializer for `Boolean`.
BooleanSerializer.BooleanSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
BooleanValue	Boxed serializable and comparable boolean type, representing the primitive type `boolean`.
BooleanValueComparator	Specialized comparator for BooleanValue based on CopyableValueComparator.
BooleanValueParser
BooleanValueSerializer
BooleanValueSerializer.BooleanValueSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
Boundedness	The boundedness of a stream.
BoundedOutOfOrdernessWatermarks<T>	A WatermarkGenerator for situations where records are out of order, but you can place an upper bound on how far the events are out of order.
BroadcastState<K,V>	A type of state that can be created to store the state of a `BroadcastStream`.
BroadcastVariableInitializer<T,O>	A broadcast variable initializer can be used to transform a broadcast variable into another format during initialization.
BulkIterationBase<T>
BulkIterationBase.PartialSolutionPlaceHolder<OT>	Specialized operator to use as a recognizable place-holder for the input to the step function when composing the nested data flow.
BulkIterationBase.TerminationCriterionAggregationConvergence	Convergence for the termination criterion is reached if no tuple is output at current iteration for the termination criterion branch
BulkIterationBase.TerminationCriterionAggregator	Aggregator that basically only adds 1 for every output tuple of the termination criterion branch
BulkIterationBase.TerminationCriterionMapper<X>	Special Mapper that is added before a termination criterion and is only a container for an special aggregator
BulkWriter<T>	An encoder that encodes data in a bulk fashion, encoding many records together at a time.
BulkWriter.Factory<T>	A factory that creates a `BulkWriter`.
ByteArrayInputStreamWithPos	Un-synchronized stream similar to Java's ByteArrayInputStream that also exposes the current position.
ByteArrayOutputStreamWithPos	Un-synchronized stream similar to Java's ByteArrayOutputStream that also exposes the current position.
ByteComparator
ByteParser
BytePrimitiveArrayComparator
BytePrimitiveArraySerializer	A serializer for byte arrays.
BytePrimitiveArraySerializer.BytePrimitiveArraySerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
ByteSerializer	Type serializer for `Byte`.
ByteSerializer.ByteSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
ByteValue	Boxed serializable and comparable byte type, representing the primitive type `byte` (signed 8 bit integer).
ByteValueComparator	Specialized comparator for ByteValue based on CopyableValueComparator.
ByteValueParser	Parses a decimal text field into a `ByteValue`.
ByteValueSerializer
ByteValueSerializer.ByteValueSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
Bzip2InputStreamFactory	Factory for Bzip2 decompressors.
CacheSupportedPipelineExecutor	The pipeline executor that support caching intermediate dataset.
CachingSupplier<T>	A `Supplier` that returns a single, lazily instantiated, value.
CharComparator
CharPrimitiveArrayComparator
CharPrimitiveArraySerializer	A serializer for char arrays.
CharPrimitiveArraySerializer.CharPrimitiveArraySerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
CharSerializer	Type serializer for `Character`.
CharSerializer.CharSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
CharValue	Boxed serializable and comparable character type, representing the primitive type `char`.
CharValueComparator	Specialized comparator for CharValue based on CopyableValueComparator.
CharValueSerializer
CharValueSerializer.CharValueSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
CheckedSupplier<R>	Similar to `Supplier` but can throw `Exception`.
CheckpointableInputFormat<S extends InputSplit,T extends Serializable>	An interface that describes `InputFormat`s that allow checkpointing/restoring their state.
CheckpointingOptions	A collection of all configuration options that relate to checkpoints and savepoints.
CheckpointListener	This interface is typically only needed for transactional interaction with the "outside world", like committing external side effects on checkpoints.
CheckpointType	Describes the type in which a checkpoint should be taken.
ChildFirstClassLoader	A variant of the URLClassLoader that first loads from the URLs and only after that from the parent.
ChillSerializerRegistrar	Interface for flink-core to interact with the FlinkChillPackageRegistrar in flink-java.
ClassLoaderUtil	Utilities for information with respect to class loaders, specifically class loaders for the dynamic loading of user defined classes.
CleanupOptions	`ConfigOption` collection for the configuration of repeatable cleanup of resource cleanup after a job reached a globally-terminated state.
CleanupWhenUnsuccessful	`OutputFormat`s may implement this interface to run a cleanup hook when the execution is not successful.
Clock	A clock that gives access to time.
CloseableIterable<T>	This interface represents an iterable that is also closeable.
CloseableIterable.Empty<T>	Empty iterator.
CloseableIterator<T>	This interface represents an `Iterator` that is also `AutoCloseable`.
CloseableIterator.IteratorAdapter<E>	Adapter from `Iterator` to `CloseableIterator`.
CloseableRegistry	This class allows to register instances of `Closeable`, which are all closed if this registry is closed.
CloseShieldOutputStream	A proxy output stream that prevents the underlying output stream from being closed.
ClosingFSDataInputStream	This class is a `WrappingProxy` for `FSDataInputStream` that is used to implement a safety net against unclosed streams.
ClosingFSDataOutputStream	This class is a `WrappingProxy` for `FSDataOutputStream` that is used to implement a safety net against unclosed streams.
ClosureCleaner	The closure cleaner is a utility that tries to truncate the closure (enclosing instance) of non-static inner classes (created for inline transformation functions).
ClusterOptions	Options which control the cluster behaviour.
ClusterOptions.UncaughtExceptionHandleMode
ClusterOptions.UserSystemExitMode	The mode of how to handle user code attempting to exit JVM.
CoGroupFunction<IN1,IN2,O>	The interface for CoGroup functions.
CoGroupOperatorBase<IN1,IN2,OUT,FT extends CoGroupFunction<IN1,IN2,OUT>>
CoGroupRawOperatorBase<IN1,IN2,OUT,FT extends CoGroupFunction<IN1,IN2,OUT>>
CoGroupRawOperatorBase.SimpleListIterable<IN>
CollectionExecutor	Execution utility for serial, local, collection-based executions of Flink programs.
CollectionUtil	Simple utility to work with Java collections.
Collector<T>	Collects a record and forwards it.
CombineFunction<IN,OUT>	Generic interface used for combine functions ("combiners").
Committer<CommT>	Deprecated. Please use `Committer`.
Committer<CommT>	The `Committer` is responsible for committing the data staged by the `TwoPhaseCommittingSink.PrecommittingSinkWriter` in the second step of a two-phase commit protocol.
Committer.CommitRequest<CommT>	A request to commit a specific committable.
CommonRangeBoundaries<T>
CompilerHints	A class encapsulating compiler hints describing the behavior of the user function.
ComponentClassLoader	A `URLClassLoader` that restricts which classes can be loaded to those contained within the given classpath, except classes from a given set of packages that are either loaded owner or component-first.
CompositeSerializer<T>	Base class for composite serializers.
CompositeSerializer.PrecomputedParameters	This class holds composite serializer parameters which can be precomputed in advanced for better performance.
CompositeType<T>	Base type information class for Tuple and Pojo types
CompositeType.FlatFieldDescriptor
CompositeType.InvalidFieldReferenceException
CompositeType.TypeComparatorBuilder<T>
CompositeTypeComparator<T>
CompositeTypeSerializerSnapshot<T,S extends TypeSerializer<T>>	A `CompositeTypeSerializerSnapshot` is a convenient serializer snapshot class that can be used by simple serializers which 1) delegates its serialization to multiple nested serializers, and 2) may contain some extra static information that needs to be persisted as part of its snapshot.
CompositeTypeSerializerSnapshot.OuterSchemaCompatibility	Indicates schema compatibility of the serializer configuration persisted as the outer snapshot.
CompositeTypeSerializerUtil	Utilities for the `CompositeTypeSerializerSnapshot`.
CompositeTypeSerializerUtil.IntermediateCompatibilityResult<T>
CompressedSerializedValue<T>	An extension of `SerializedValue` that compresses the value after the serialization.
ConfigConstants	This class contains all constants for the configuration.
ConfigOption<T>	A `ConfigOption` describes a configuration parameter.
ConfigOptions	`ConfigOptions` are used to build a `ConfigOption`.
ConfigOptions.ListConfigOptionBuilder<E>	Builder for `ConfigOption` of list of type `ConfigOptions.ListConfigOptionBuilder`.
ConfigOptions.OptionBuilder	The option builder is used to create a `ConfigOption`.
ConfigOptions.TypedConfigOptionBuilder<T>	Builder for `ConfigOption` with a defined atomic type.
Configuration	Lightweight configuration object which stores key/value pairs.
ConfigurationException	Exception which occurs when creating a configuration object fails.
ConfigurationUtils	Utility class for `Configuration` related helper functions.
ConfigUtils	General utilities for parsing values to configuration options.
ConnectionLimitingFactory	A wrapping factory that adds a `LimitedConnectionsFileSystem` to a file system.
ConvergenceCriterion<T extends Value>	Used to check for convergence.
CopyableValue<T>	Interface to be implemented by basic types that support to be copied efficiently.
CopyableValueComparator<T extends CopyableValue<T> & Comparable<T>>	Comparator for all Value types that extend Key
CopyableValueSerializer<T extends CopyableValue<T>>
CopyableValueSerializer.CopyableValueSerializerSnapshot<T extends CopyableValue<T>>	`TypeSerializerSnapshot` for the `CopyableValueSerializer`.
CopyingIterator<E>	Wraps an iterator to return deep copies of the original iterator's elements.
CopyingListCollector<T>	A `Collector` that collects deep copies of its elements in a list.
CoreOptions	The set of configuration options for core parameters.
CPUResource	Represents CPU resource.
CrossFunction<IN1,IN2,OUT>	Interface for Cross functions.
CrossOperatorBase<IN1,IN2,OUT,FT extends CrossFunction<IN1,IN2,OUT>>
CrossOperatorBase.CrossHint	The cross hint tells the system which sizes to expect from the data sets
CrossOperatorBase.CrossWithLarge	Marker interface to declare the second input as the larger one.
CrossOperatorBase.CrossWithSmall	Marker interface to declare the second input as the smaller one.
DataDistribution
DataInputDeserializer	A simple and efficient deserializer for the `DataInput` interface.
DataInputView	This interface defines a view over some memory that can be used to sequentially read the contents of the memory.
DataInputViewStream	An input stream that draws its data from a `DataInputView`.
DataInputViewStreamWrapper	Utility class that turns an `InputStream` into a `DataInputView`.
DataOutputSerializer	A simple and efficient serializer for the `DataOutput` interface.
DataOutputView	This interface defines a view over some memory that can be used to sequentially write contents to the memory.
DataOutputViewStream
DataOutputViewStreamWrapper	Utility class that turns an `OutputStream` into a `DataOutputView`.
DateComparator
DateSerializer
DateSerializer.DateSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
Deadline	This class stores a deadline, as obtained via `Deadline.now()` or from `Deadline.plus(Duration)`.
DefaultExecutorServiceLoader	The default implementation of the `PipelineExecutorServiceLoader`.
DefaultInputSplitAssigner	This is the default implementation of the `InputSplitAssigner` interface.
DefaultPluginManager	Default implementation of `PluginManager`.
DeflateInflaterInputStreamFactory	Factory for input streams that decompress the "deflate" compression format.
DelegatingConfiguration	A configuration that manages a subset of keys with a common prefix from a given configuration.
DelegationTokenProvider	Delegation token provider API.
DelegationTokenProvider.ObtainedDelegationTokens	Container for obtained delegation tokens.
DelegationTokenReceiver	Delegation token receiver API.
DelimitedInputFormat<OT>	Base implementation for input formats that split the input at a delimiter into records.
DeltaIterationBase<ST,WT>	A DeltaIteration is similar to a `BulkIterationBase`, but maintains state across the individual iteration steps.
DeltaIterationBase.SolutionSetPlaceHolder<ST>	Specialized operator to use as a recognizable place-holder for the solution set input to the step function.
DeltaIterationBase.WorksetPlaceHolder<WT>	Specialized operator to use as a recognizable place-holder for the working set input to the step function.
DeploymentOptions	The `configuration options` relevant for all Executors.
DeploymentOptionsInternal	Internal options used during deployment.
DescribedEnum	Describe enum constants used in `ConfigOption`s.
Description	Description for `ConfigOption`.
Description.DescriptionBuilder	Builder for `Description`.
DeserializationException	An exception specifying that the deserialization caused an error.
DeserializationSchema<T>	The deserialization schema describes how to turn the byte messages delivered by certain data sources (for example Apache Kafka) into data types (Java/Scala objects) that are processed by Flink.
DeserializationSchema.InitializationContext	A contextual information provided for `DeserializationSchema.open(InitializationContext)` method.
DetachedJobExecutionResult	The `JobExecutionResult` returned by a context environment when executing a job in detached mode.
DirectoryBasedPluginFinder	This class is used to create a collection of `PluginDescriptor` based on directory structure for a given plugin root folder.
Disposable	Interface for classes that can be disposed, i.e.
DistributedCache	DistributedCache provides static methods to write the registered cache files into job configuration or decode them from job configuration.
DistributedCache.DistributedCacheEntry	Meta info about an entry in `DistributedCache`.
DoubleComparator
DoubleCounter	An accumulator that sums up `double` values.
DoubleMaximum	An accumulator that finds the maximum `double` value.
DoubleMinimum	An accumulator that finds the minimum `double` value.
DoubleParser	Parses a text field into a Double.
DoublePrimitiveArrayComparator
DoublePrimitiveArraySerializer	A serializer for double arrays.
DoublePrimitiveArraySerializer.DoublePrimitiveArraySerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
DoubleSerializer	Type serializer for `Double`.
DoubleSerializer.DoubleSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
DoubleSumAggregator	An `Aggregator` that sums up `DoubleValue` values.
DoubleValue	Boxed serializable and comparable double precision floating point type, representing the primitive type `double`.
DoubleValueComparator	Specialized comparator for DoubleValue based on CopyableValueComparator.
DoubleValueParser	Parses a text field into a DoubleValue.
DoubleValueSerializer
DoubleValueSerializer.DoubleValueSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
DoubleZeroConvergence	A `ConvergenceCriterion` over an `Aggregator` that defines convergence as reached once the aggregator holds the value zero.
DualInputOperator<IN1,IN2,OUT,FT extends Function>	Abstract operator superclass for all operators that have two inputs, like "Join", "CoGroup", or "Cross".
DualInputSemanticProperties	Container for the semantic properties associated to a dual input operator.
DuplicatingFileSystem	An extension interface for `FileSystems` that can perform cheap DFS side duplicate operation.
DuplicatingFileSystem.CopyRequest	A pair of source and destination to duplicate a file.
DynamicCodeLoadingException	An exception that is thrown if the dynamic instantiation of code fails.
Either<L,R>	This type represents a value of one two possible types, Left or Right (a disjoint union), inspired by Scala's Either type.
Either.Left<L,R>	A left value of `Either`
Either.Right<L,R>	A right value of `Either`
EitherSerializer<L,R>	A `TypeSerializer` for the `Either` type of the Java class.
EitherSerializerSnapshot<L,R>	Deprecated. this snapshot class is no longer used by any serializers.
EitherTypeInfo<L,R>	A `TypeInformation` for the `Either` type of the Java API.
EitherTypeInfoFactory<L,R>
Encoder<IN>	A `Encoder` is used by the streaming file sink to perform the actual writing of the incoming elements to the files in a bucket.
EntropyInjectingFileSystem	An interface to be implemented by a `FileSystem` that is aware of entropy injection.
EntropyInjector	This class offers utilities for entropy injection for FileSystems that implement `EntropyInjectingFileSystem`.
EnumComparator<T extends Enum<T>>
EnumSerializer<T extends Enum<T>>	`TypeSerializer` for Java enums.
EnumSerializer.EnumSerializerSnapshot<T extends Enum<T>>	`TypeSerializerSnapshot` for `EnumSerializer`.
EnumTypeInfo<T extends Enum<T>>	A `TypeInformation` for java enumeration types.
ExceptionUtils	A collection of utility functions for dealing with exceptions and exception workflows.
ExecutionConfig	A config to define the behavior of the program execution.
ExecutionConfig.ClosureCleanerLevel	Configuration settings for the closure cleaner.
ExecutionConfig.GlobalJobParameters	Abstract class for a custom user configuration object registered at the execution config.
ExecutionConfig.SerializableSerializer<T extends com.esotericsoftware.kryo.Serializer<?> & Serializable>
ExecutionMode	Deprecated. The `ExecutionMode` is deprecated because it's only used in DataSet APIs.
ExecutionOptions	`ConfigOption`s specific for a single execution of a user program.
Executors	Collection of `Executor` and `ExecutorService` implementations.
ExecutorThreadFactory	A thread factory intended for use by critical thread pools.
ExecutorThreadFactory.Builder	Builder for `ExecutorThreadFactory`.
ExecutorUtils	Utilities for `Executors`.
ExponentialBackoffRetryStrategy	An implementation of `RetryStrategy` that retries that has an exponential backoff with a cap.
ExternallyInducedSourceReader<T,SplitT extends SourceSplit>	Sources that implement this interface delay checkpoints when receiving a trigger message from the checkpoint coordinator to the point when their input data/events indicate that a checkpoint should be triggered.
ExternalResource	An external resource.
ExternalResourceDriver	Driver which takes the responsibility to manage and provide the information of external resource.
ExternalResourceDriverFactory	Factory for `ExternalResourceDriver`.
ExternalResourceInfo	Contains the information of an external resource.
ExternalResourceOptions	Configuration options for external resources and external resource drivers.
FailureEnricher	Failure Enricher enabling custom logic and attaching metadata in the form of labels to each type of failure as tracked in the JobMaster.
FailureEnricher.Context	An interface used by the `FailureEnricher`.
FailureEnricher.Context.FailureType	Type of failure.
FailureEnricherFactory	Factory class for creating `FailureEnricher`.
FallbackKey	A key with FallbackKeys will fall back to the FallbackKeys if it itself is not configured.
FatalExitExceptionHandler	Handler for uncaught exceptions that will log the exception and kill the process afterwards.
FieldList	Immutable ordered list of fields IDs.
FieldParser<T>	A FieldParser is used parse a field from a sequence of bytes.
FieldParser.ParseErrorState	An enumeration of different types of errors that may occur.
FieldSerializer	This class is for the serialization of java.lang.reflect.Field, which doesn't implement Serializable, therefore readObject/writeObject need to be implemented in classes where there is a field of type java.lang.reflect.Field.
FieldSet	Immutable unordered collection of fields IDs.
FileInputFormat<OT>	The base class for `RichInputFormat`s that read from files.
FileInputFormat.FileBaseStatistics	Encapsulation of the basic statistics the optimizer obtains about a file.
FileInputFormat.InputSplitOpenThread	Obtains a DataInputStream in an thread that is not interrupted.
FileInputSplit	A file input split provides information on a particular part of a file, possibly hosted on a distributed file system and replicated among several hosts.
FileLock	A file lock used for avoiding race condition among multiple threads/processes.
FileOutputFormat<IT>	The abstract base class for all Rich output formats that are file based.
FileOutputFormat.OutputDirectoryMode	Behavior for creating output directories.
FilePathFilter	The `FilePathFilter.filterPath(Path)` method is responsible for deciding if a path is eligible for further processing or not.
FilePathFilter.DefaultFilter	The default file path filtering method and is used if no other such function is provided.
FileStatus	Interface that represents the client side information for a file independent of the file system.
FileSystem	Abstract base class of all file systems used by Flink.
FileSystem.WriteMode	The possible write modes.
FileSystemFactory	A factory to create file systems.
FileSystemKind	An enumeration defining the kind and characteristics of a `FileSystem`.
FileSystemSafetyNet	The FileSystemSafetyNet can be used to guard a thread against `FileSystem` stream resource leaks.
FileUtils	This is a utility class to deal files and directories.
FilterFunction<T>	A filter function is a predicate applied individually to each record.
FilterOperatorBase<T,FT extends FlatMapFunction<T,T>>
FinalizeOnMaster	This interface may be implemented by `OutputFormat`s to have the master finalize them globally.
FinalizeOnMaster.FinalizationContext	A context that provides parallelism and finished attempts infos.
FixedRetryStrategy	An implementation of `RetryStrategy` that retries at a fixed delay.
FlatJoinFunction<IN1,IN2,OUT>	Interface for Join functions.
FlatMapFunction<T,O>	Base interface for flatMap functions.
FlatMapOperatorBase<IN,OUT,FT extends FlatMapFunction<IN,OUT>>
FlinkConnectorRateLimiter	An interface to create a ratelimiter
FlinkException	Base class of all Flink-specific checked exceptions.
FlinkExpectedException	This class is just used to pass diagnostic message of some excepted procedure.
FlinkRuntimeException	Base class of all Flink-specific unchecked exceptions.
FlinkSecurityManager	`FlinkSecurityManager` to control certain behaviors that can be captured by Java system security manager.
FlinkUserCodeClassLoader	This class loader accepts a custom handler if an exception occurs in `FlinkUserCodeClassLoader.loadClass(String, boolean)`.
FlinkUserCodeClassLoaders	Gives the URLClassLoader a nicer name for debugging purposes.
FlinkUserCodeClassLoaders.ParentFirstClassLoader	Regular URLClassLoader that first loads from the parent and only after that from the URLs.
FlinkUserCodeClassLoaders.ResolveOrder	Class resolution order for Flink URL `ClassLoader`.
FlinkUserCodeClassLoaders.SafetyNetWrapperClassLoader	Ensures that holding a reference on the context class loader outliving the scope of user code does not prevent the user classloader to be garbage collected (FLINK-16245).
FloatComparator
FloatParser	Parses a text field into a `Float`.
FloatPrimitiveArrayComparator
FloatPrimitiveArraySerializer	A serializer for float arrays.
FloatPrimitiveArraySerializer.FloatPrimitiveArraySerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
FloatSerializer	Type serializer for `Float`.
FloatSerializer.FloatSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
FloatValue	Boxed serializable and comparable single precision floating point type, representing the primitive type `float`.
FloatValueComparator	Specialized comparator for FloatValue based on CopyableValueComparator.
FloatValueParser	Parses a text field into a `FloatValue`
FloatValueSerializer
FloatValueSerializer.FloatValueSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
Formatter	Allows providing multiple formatters for the description.
FractionalTypeInfo<T>	Type information for numeric fractional primitive types (double, float).
FSDataInputStream	Interface for a data input stream to a file on a `FileSystem`.
FSDataInputStreamWrapper	Simple forwarding wrapper around `FSDataInputStream`.
FSDataOutputStream	An output stream to a file that is created via a `FileSystem`.
FSDataOutputStreamWrapper	Simple forwarding wrapper around `FSDataInputStream`.
Function	The base interface for all user-defined functions.
FunctionUtils	Utility class that contains helper methods to work with Flink `Function` class.
FunctionUtils	Utility class for Flink's functions.
FunctionWithException<T,R,E extends Throwable>	A functional interface for a `Function` that may throw exceptions.
FutureConsumerWithException<T,E extends Throwable>	A checked extension of the `Consumer` interface which rethrows exceptions wrapped in a `CompletionException`.
FutureTaskWithException<V>	`FutureTask` that also implements `RunnableWithException`.
FutureUtils	A collection of utilities that expand the usage of `CompletableFuture`.
FutureUtils.ConjunctFuture<T>	A future that is complete once multiple other futures completed.
FutureUtils.RetryException	Exception with which the returned future is completed if the `FutureUtils.retry(Supplier, int, Executor)` operation fails.
GatedRateLimiter	An implementation of `RateLimiter` that completes defined number of futures in-between the external notification events.
GenericArraySerializer<C>	A serializer for arrays of objects.
GenericArraySerializerConfigSnapshot<C>	Deprecated. this is deprecated and no longer used by the `GenericArraySerializer`.
GenericArraySerializerSnapshot<C>	Point-in-time configuration of a `GenericArraySerializer`.
GenericCsvInputFormat<OT>
GenericDataSinkBase<IN>	Operator for nodes that act as data sinks, storing the data they receive.
GenericDataSourceBase<OUT,T extends InputFormat<OUT,?>>	Abstract superclass for data sources in a Pact plan.
GenericDataSourceBase.SplitDataProperties<T>
GenericInputFormat<OT>	Generic base class for all Rich inputs that are not based on files.
GenericInputSplit	A generic input split that has only a partition number.
GenericPairComparator<T1,T2>
GenericTypeComparator<T extends Comparable<T>>	TypeComparator for all types that extend Comparable.
GenericTypeInfo<T>
GenericTypeSerializerSnapshot<T,S extends TypeSerializer>	Base `TypeSerializerSnapshot` for serializers for generic types.
GlobalCommitter<CommT,GlobalCommT>	Deprecated. Please use `WithPostCommitTopology` with `StandardSinkTopologies#addGlobalCommitter`.
GlobalConfiguration	Global configuration object for Flink.
GlobFilePathFilter	Class for determining if a particular file should be included or excluded based on a set of include and exclude glob filters.
GroupCombineFunction<IN,OUT>	Generic interface used for combine functions ("combiners").
GroupCombineOperatorBase<IN,OUT,FT extends GroupCombineFunction<IN,OUT>>	Base operator for the combineGroup transformation.
GroupReduceFunction<T,O>	The interface for group reduce functions.
GroupReduceOperatorBase<IN,OUT,FT extends GroupReduceFunction<IN,OUT>>
GuavaFlinkConnectorRateLimiter	An implementation of `FlinkConnectorRateLimiter` that uses Guava's RateLimiter for rate limiting.
GuavaRateLimiter	An implementation of `RateLimiter` based on Guava's RateLimiter.
GzipInflaterInputStreamFactory	Factory for input streams that decompress the GZIP compression format.
HeartbeatManagerOptions	The set of configuration options relating to heartbeat manager settings.
HighAvailabilityOptions	The set of configuration options relating to high-availability settings.
Histogram	Histogram accumulator, which builds a histogram in a distributed manner.
HistoryServerOptions	The set of configuration options relating to the HistoryServer.
HtmlFormatter	Formatter that transforms `Description` into Html representation.
IgnoreShutdownRejectedExecutionHandler	Rejected executions are ignored or logged in debug if the executor is `shutdown`.
IllegalConfigurationException	An `IllegalConfigurationException` is thrown when the values in a given `Configuration` are not valid.
IndexedCombinedWatermarkStatus	Represents combined value and status of a watermark for a set number of input partial watermarks.
InflaterInputStreamFactory<T extends InputStream>	Creates a new instance of a certain subclass of `InflaterInputStream`.
IngestionTimeAssigner<T>	A timestamp assigner that assigns timestamps based on the machine's wall clock.
InitializeOnMaster	This interface may be implemented by `OutputFormat`s to have the master initialize them globally.
InlineElement	Part of description that represents an element inside a block e.g.
InnerJoinOperatorBase<IN1,IN2,OUT,FT extends FlatJoinFunction<IN1,IN2,OUT>>
InputDependencyConstraint	Deprecated. `InputDependencyConstraint` is not used anymore and will be deleted in one of the future versions.
InputFormat<OT,T extends InputSplit>	The base interface for data sources that produces records.
InputSplit	This interface must be implemented by all kind of input splits that can be assigned to input formats.
InputSplitAssigner	An input split assigner distributes the `InputSplit`s among the instances on which a data source exists.
InputSplitSource<T extends InputSplit>	InputSplitSources create `InputSplit`s that define portions of data to be produced by `InputFormat`s.
InputStatus	An `InputStatus` indicates the availability of data from an asynchronous input.
InputStreamFSInputWrapper	This class wraps an `InputStream` and exposes it as `FSDataInputStream`.
InputTypeConfigurable	`OutputFormat`s can implement this interface to be configured with the data type they will operate on.
InstantComparator	Comparator for comparing Java Instant.
InstantiationUtil	Utility class to create instances from class objects and checking failure reasons.
InstantiationUtil.ClassLoaderObjectInputStream	A custom ObjectInputStream that can load classes using a specific ClassLoader.
InstantSerializer	Serializer for serializing/deserializing Instant values including null values.
InstantSerializer.InstantSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
IntComparator
IntCounter	An accumulator that sums up `Integer` values.
IntegerTypeInfo<T>	Type information for numeric integer primitive types: int, long, byte, short, character.
InternalCheckpointListener	The internal checkpoint listener add another `InternalCheckpointListener.notifyCheckpointSubsumed(long)` interface for internal usage.
IntMaximum	An accumulator that finds the maximum `integer` value.
IntMinimum	An accumulator that finds the minimum `integer` value.
IntParser	Parses a decimal text field into a IntValue.
IntPrimitiveArrayComparator
IntPrimitiveArraySerializer	A serializer for int arrays.
IntPrimitiveArraySerializer.IntPrimitiveArraySerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
IntSerializer	Type serializer for `Integer` (and `int`, via auto-boxing).
IntSerializer.IntSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
IntValue	Boxed serializable and comparable integer type, representing the primitive type `int`.
IntValueComparator	Specialized comparator for IntValue based on CopyableValueComparator.
IntValueParser	Parses a decimal text field into a IntValue.
IntValueSerializer
IntValueSerializer.IntValueSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
InvalidProgramException	An exception thrown to indicate that the composed program is invalid.
InvalidTypesException	A special case of the `InvalidProgramException`, indicating that the types used in an operation are invalid or inconsistent.
IOReadableWritable	This interface must be implemented by every class whose objects have to be serialized to their binary representation and vice-versa.
IOUtils	An utility class for I/O related functionality.
IterableIterator<E>	An `Iterator` that is also `Iterable` (often by returning itself).
IterableUtils	A collection of utilities that expand the usage of `Iterable`.
IterationOperator
IterationRuntimeContext	A specialization of the `RuntimeContext` available in iterative computations of the DataSet API.
IteratorSourceEnumerator<SplitT extends IteratorSourceSplit<?,?>>	A `SplitEnumerator` for iterator sources.
IteratorSourceReader<E,IterT extends Iterator<E>,SplitT extends IteratorSourceSplit<E,IterT>>	A `SourceReader` that returns the values of an iterator, supplied via an `IteratorSourceSplit`.
IteratorSourceReaderBase<E,O,IterT extends Iterator<E>,SplitT extends IteratorSourceSplit<E,IterT>>	A `SourceReader` that returns the values of an iterator, supplied via an `IteratorSourceSplit`.
IteratorSourceSplit<E,IterT extends Iterator<E>>	A `SourceSplit` that represents a sequence of elements captured in an iterator.
JacksonMapperFactory	Factory for Jackson mappers.
JarUtils	Utility functions for jar files.
JavaEitherSerializerSnapshot<L,R>	Snapshot class for the `EitherSerializer`.
JavaSerializer<T>	This is a reimplementation of Kryo's `JavaSerializer`, that additionally makes sure the `ObjectInputStream` used for deserialization specifically uses Kryo's registered classloader.
JavaToValueConverter
JMXServerOptions	The set of configuration options relating to JMX server.
JMXService	Provide a JVM-wide singleton JMX Service.
JobClient	A client that is scoped to a specific job.
JobExecutionResult	The result of a job execution.
JobID	Unique (at least statistically unique) identifier for a Flink Job.
JobListener	A listener that is notified on specific job status changed, which should be firstly registered by `#registerJobListener` of execution environments.
JobManagerOptions	Configuration options for the JobManager.
JobManagerOptions.HybridPartitionDataConsumeConstraint	Constraints of upstream hybrid partition data consumption by downstream.
JobManagerOptions.JobStoreType	Type of job store implementation.
JobManagerOptions.SchedulerType	Type of scheduler implementation.
JobStatus	Possible states of a job once it has been accepted by the dispatcher.
JobStatusHook	Hooks on job status changing.
JobSubmissionResult	The result of submitting a job to a JobManager.
JoinFunction<IN1,IN2,OUT>	Interface for Join functions.
JoinHashMap<BT>
JoinOperatorBase<IN1,IN2,OUT,FT extends FlatJoinFunction<IN1,IN2,OUT>>
JoinOperatorBase.JoinHint	An enumeration of hints, optionally usable to tell the system how exactly execute the join.
Key<T>	Deprecated. The Key type is a relict of a deprecated and removed API and will be removed in future (2.0) versions as well.
KeyedStateStore	This interface contains methods for registering keyed state with a managed store.
KeyFieldOutOfBoundsException	An exception specifying that a required key field was not set in a record, i.e.
Keys<T>
Keys.ExpressionKeys<T>	Represents (nested) field access through string and integer-based keys
Keys.IncompatibleKeysException
Keys.SelectorFunctionKeys<T,K>
KeySelector<IN,KEY>	The `KeySelector` allows to use deterministic objects for operations such as reduce, reduceGroup, join, coGroup, etc.
KryoRegistration	A `KryoRegistration` resembles a registered class and its serializer in Kryo.
KryoRegistration.SerializerDefinitionType	IMPORTANT: the order of the enumerations must not change, since their ordinals are used for serialization.
KryoSerializer<T>	A type serializer that serializes its type using the Kryo serialization framework (https://github.com/EsotericSoftware/kryo).
KryoSerializerSnapshot<T>	`TypeSerializerSnapshot` for `KryoSerializer`.
KryoUtils	Convenience methods for Kryo
LambdaUtil	This class offers utility functions for Java's lambda features.
LegacySerializerSnapshotTransformer<T>	This interface provides a way for `TypeSerializer`s to transform a legacy `TypeSerializerSnapshot` used in versions before Flink 1.7 during deserialization.
LimitedConnectionsFileSystem	A file system that limits the number of concurrently open input streams, output streams, and total streams for a target file system.
LimitedConnectionsFileSystem.ConnectionLimitingSettings	A simple configuration data object capturing the settings for limited connections.
LimitedConnectionsFileSystem.StreamTimeoutException	A special IOException, indicating a timeout in the data output stream.
LineBreakElement	Represents a line break in the `Description`.
LinkedOptionalMap<K,V>	A LinkedOptionalMap is an order preserving map (like `LinkedHashMap`) where keys have a unique string name, but are optionally present, and the values are optional.
LinkedOptionalMap.ConsumerWithException<K,V,E extends Throwable>	A `Consumer` that throws exceptions.
LinkedOptionalMap.KeyValue<K,V>	Key-value pairs stored by the underlying map.
LinkedOptionalMap.MergeResult<K,V>	The result of merging two `LinkedOptionalMap`s using `LinkedOptionalMap.mergeRightIntoLeft(LinkedOptionalMap, LinkedOptionalMap)`.
LinkedOptionalMapSerializer	LinkedOptionalMapSerializer - A serializer of `LinkedOptionalMap`.
LinkElement	Element that represents a link in the `Description`.
ListAccumulator<T>	This accumulator stores a collection of objects.
ListCollector<T>	A `Collector` that puts the collected elements into a given list.
ListElement	Represents a list in the `Description`.
ListKeyGroupedIterator<E>	The KeyValueIterator returns a key and all values that belong to the key (share the same key).
ListSerializer<T>	A serializer for `Lists`.
ListSerializerSnapshot<T>	Snapshot class for the `ListSerializer`.
ListState<T>	`State` interface for partitioned list state in Operations.
ListStateDescriptor<T>	A `StateDescriptor` for `ListState`.
ListTypeInfo<T>	A `TypeInformation` for the list types of the Java API.
ListValue<V extends Value>	Generic list base type for PACT programs that implements the Value and List interfaces.
LocalBlockLocation	Implementation of the `BlockLocation` interface for a local file system.
LocalDataInputStream	The `LocalDataInputStream` class is a wrapper class for a data input stream to the local file system.
LocalDataOutputStream	The `LocalDataOutputStream` class is a wrapper class for a data output stream to the local file system.
LocalDateComparator	This class can not extend `BasicTypeComparator`, because LocalDate is a Comparable of ChronoLocalDate instead of Comparable of LocalDate.
LocalDateSerializer
LocalDateSerializer.LocalDateSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
LocalDateTimeComparator	This class can not extend `BasicTypeComparator`, because LocalDateTime is a Comparable of ChronoLocalDateTime instead of Comparable of LocalDateTime.
LocalDateTimeSerializer
LocalDateTimeSerializer.LocalDateTimeSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
LocalFileStatus	The class `LocalFileStatus` provides an implementation of the `FileStatus` interface for the local file system.
LocalFileSystem	The class `LocalFileSystem` is an implementation of the `FileSystem` interface for the local file system of the machine where the JVM runs.
LocalFileSystemFactory	A factory for the `LocalFileSystem`.
LocalRecoverableFsDataOutputStream	A `RecoverableFsDataOutputStream` for the `LocalFileSystem`.
LocalRecoverableWriter	A `RecoverableWriter` for the `LocalFileSystem`.
LocalTimeComparator
LocalTimeSerializer
LocalTimeSerializer.LocalTimeSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
LocalTimeTypeInfo<T extends java.time.temporal.Temporal>	Type information for Java LocalDate/LocalTime/LocalDateTime.
LocatableInputSplit	A locatable input split is an input split referring to input data which is located on one or more hosts.
LocatableInputSplitAssigner	The locatable input split assigner assigns to each host splits that are local, before assigning splits that are not local.
LocatedFileStatus	A `LocatedFileStatus` is a `FileStatus` that contains additionally the location information of the file directly.
LongComparator
LongCounter	An accumulator that sums up `long` values.
LongFunctionWithException<R,E extends Throwable>	Similar to `LongFunction` but can throw `Exception`.
LongMaximum	An accumulator that finds the maximum `long` value.
LongMinimum	An accumulator that finds the minimum `long` value.
LongParser	Parses a decimal text field into a LongValue.
LongPrimitiveArrayComparator
LongPrimitiveArraySerializer	A serializer for long arrays.
LongPrimitiveArraySerializer.LongPrimitiveArraySerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
LongSerializer	Type serializer for `Long`.
LongSerializer.LongSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
LongSumAggregator	An `Aggregator` that sums up long values.
LongValue	Boxed serializable and comparable long integer type, representing the primitive type `long`.
LongValueComparator	Specialized comparator for LongValue based on CopyableValueComparator.
LongValueParser	Parses a decimal text field into a LongValue.
LongValueSequenceIterator	The `LongValueSequenceIterator` is an iterator that returns a sequence of numbers (as `LongValue`)s.
LongValueSerializer
LongValueSerializer.LongValueSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
LongZeroConvergence	A `ConvergenceCriterion` over an `Aggregator` that defines convergence as reached once the aggregator holds the value zero.
MailboxExecutor	`Executor` like interface for a build around a mailbox-based execution model.
ManagedMemoryUseCase	Use cases of managed memory.
ManagedMemoryUseCase.Scope	Scope at which memory is managed for a use case.
ManualClock	A `Clock` implementation which allows to advance time manually.
MapFunction<T,O>	Base interface for Map functions.
MapOperatorBase<IN,OUT,FT extends MapFunction<IN,OUT>>
MapPartitionFunction<T,O>	Interface for "mapPartition" functions.
MapPartitionOperatorBase<IN,OUT,FT extends MapPartitionFunction<IN,OUT>>
MapSerializer<K,V>	A serializer for `Map`.
MapSerializerSnapshot<K,V>	Snapshot class for the `MapSerializer`.
MapState<UK,UV>	`State` interface for partitioned key-value state.
MapStateDescriptor<UK,UV>	A `StateDescriptor` for `MapState`.
MapTypeInfo<K,V>	Special `TypeInformation` used by `MapStateDescriptor`.
MapValue<K extends Value,V extends Value>	Generic map base type for PACT programs that implements the Value and Map interfaces.
MaskUtils	Utilities for reading and writing binary masks.
MathUtils	Collection of simple mathematical routines.
MemorySegment	This class represents a piece of memory managed by Flink.
MemorySegmentFactory	A factory for memory segments (`MemorySegment`).
MemorySegmentInputStreamWithPos	Un-synchronized input stream using the given memory segment.
MemorySegmentProvider	The provider used for requesting and releasing batch of memory segments.
MemorySegmentSource	Interface describing entities that can provide memory segments.
MemorySegmentWritable	Provides the interface for write(Segment).
MemorySize	MemorySize is a representation of a number of bytes, viewable in different units.
MemorySize.MemoryUnit	Enum which defines memory unit, mostly used to parse value from configuration file.
MemoryUtils	Utility class for memory operations.
MergingState<IN,OUT>	Extension of `AppendingState` that allows merging of state.
MetricOptions	Configuration options for metrics and metric reporters.
MetricOptions.JobStatusMetrics	Enum describing the different kinds of job status metrics.
MetricOptions.JobStatusMetricsSettings	Describes which job status metrics have been enabled.
MissingTypeInfo	A special type information signifying that the type extraction failed.
MultisetTypeInfo<T>	A `TypeInformation` for the Multiset types of the Java API.
MutableObjectIterator<E>	A simple iterator interface.
MutableURLClassLoader	URL class loader that exposes the `addURL` method in URLClassLoader.
NestedSerializersSnapshotDelegate	A NestedSerializersSnapshotDelegate represents the snapshots of multiple serializers that are used by an outer serializer.
NettyShuffleEnvironmentOptions	The set of configuration options relating to network stack.
NetUtils	Utility for various network related tasks (such as finding free ports).
NetUtils.Port	Port wrapper class which holds a `FileLock` until it releases.
NetUtils.SocketFactory	A factory for a local socket from port number.
NeverCompleteFuture	A future that never completes.
NoFetchingInput
NonParallelInput	This interface acts as a marker for input formats for inputs which cannot be split.
NonSerializableUserCodeException	An special case of the `InvalidProgramException`, indicating that a part of the program that needs to be serializable (for shipping) is not serializable.
NoOpFunction	An `AbstractRichFunction` that does nothing.
NoOpRateLimiter	A convenience implementation of `RateLimiter` that does not throttle requests.
NormalizableKey<T>	The base interface for normalizable keys.
NormalizedKeyUtil	Utilities related to `TypeComparator`.
Nothing	A type for (synthetic) operators that do not output data.
NothingTypeInfo	Placeholder type information for the `Nothing` type.
NoWatermarksGenerator<E>	An implementation of a `WatermarkGenerator` that generates no Watermarks.
NullableSerializer<T>	Serializer wrapper to add support of `null` value serialization.
NullableSerializer.NullableSerializerSnapshot<T>	Snapshot for serializers of nullable types, containing the snapshot of its original serializer.
NullAwareComparator<T>	Null-aware comparator that wraps a comparator which does not support null references.
NullByteKeySelector<T>	Used as a dummy `KeySelector` to allow using keyed operators for non-keyed use cases.
NullFieldException	An exception specifying that a required field was not set in a record, i.e.
NullKeyFieldException	An exception specifying that a required key field was not set in a record, i.e.
NullValue	Null base type for programs that implements the Key interface.
NullValueComparator	Specialized comparator for NullValue based on CopyableValueComparator.
NullValueSerializer
NullValueSerializer.NullValueSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
NumberSequenceIterator	The `NumberSequenceIterator` is an iterator that returns a sequence of numbers (as `Long`)s.
NumberSequenceSource	A data source that produces a sequence of numbers (longs).
NumberSequenceSource.NumberSequenceSplit	A split of the source, representing a number sub-sequence.
NumericTypeInfo<T>	Type information for numeric primitive types: int, long, double, byte, short, float, char.
ObjectArrayTypeInfo<T,C>
OffsetAwareOutputStream	An `OutputStream` that keeps track of its current length.
OperatingSystem	An enumeration indicating the operating system that the JVM runs on.
Operator<OUT>	Abstract base class for all operators.
OperatorInformation<OUT>	A class for holding information about an operator, such as input/output TypeInformation.
OperatorStateStore	This interface contains methods for registering operator state with a managed store.
OperatorValidationUtils	Utils for checking operators' resource and parallelism settings.
OptimizerOptions	Configuration options for the optimizer.
OptionalConsumer<T>	Utility class which allows to run code depending on whether the optional has a value or is empty.
OptionalFailure<T>	Wrapper around an object representing either a success (with a given value) or a failure cause.
OptionalUtils	Utilities for working with `Optional`.
Order	Enumeration representing order.
Ordering	This class represents an ordering on a set of fields.
OuterJoinOperatorBase<IN1,IN2,OUT,FT extends FlatJoinFunction<IN1,IN2,OUT>>
OuterJoinOperatorBase.OuterJoinType
OutputFormat<IT>	The base interface for outputs that consumes records.
OutputFormat.InitializationContext	The context exposes some runtime info for initializing output format.
OutputFormatBase<OUT,V>	OutputFormatBase is the common abstract class for output formats.
OutputStreamAndPath	An output stream and a path.
OutputTag<T>	An `OutputTag` is a typed and named tag to use for tagging side outputs of an operator.
ParseException	Exception indicating that the parsing of input contents has failed because the data does not match the configured parser.
Partitioner<K>	Function to implement a custom partition assignment for keys.
PartitionOperatorBase<IN>
PartitionOperatorBase.PartitionMethod
Path	Names a file or directory in a `FileSystem`.
Pipeline	Common interface for Flink pipelines.
PipelineExecutor	The entity responsible for executing a `Pipeline`, i.e.
PipelineExecutorFactory	A factory for selecting and instantiating the adequate `PipelineExecutor` based on a provided `Configuration`.
PipelineExecutorServiceLoader	An interface to be implemented by the entity responsible for finding the correct `PipelineExecutor` to execute a given `Pipeline`.
PipelineOptions	The `configuration options` for job execution.
PipelineOptions.VertexDescriptionMode	The mode how we organize description of a vertex.
PipelineOptionsInternal	Pipeline options that are not meant to be used by the user.
Plan	This class represents Flink programs, in the form of dataflow plans.
Plugin	Interface for plugins.
PluginConfig	Stores the configuration for plugins mechanism.
PluginDescriptor	Descriptive meta information for a plugin.
PluginFileSystemFactory	A wrapper around `FileSystemFactory` that ensures the plugin classloader is used for all `FileSystem` operations.
PluginFinder	Implementations of this interface provide mechanisms to locate plugins and create corresponding `PluginDescriptor` objects.
PluginLoader	A `PluginLoader` is used by the `PluginManager` to load a single plugin.
PluginManager	PluginManager is responsible for managing cluster plugins which are loaded using separate class loaders so that their dependencies don't interfere with Flink's dependencies.
PluginUtils	Utility functions for the plugin mechanism.
PojoComparator<T>
PojoField	Represent a field definition for `PojoTypeInfo` type of objects.
PojoSerializer<T>
PojoSerializerSnapshot<T>	Snapshot class for the `PojoSerializer`.
PojoTypeInfo<T>	TypeInformation for "Java Beans"-style types.
PojoTypeInfo.NamedFlatFieldDescriptor
PostVersionedIOReadableWritable	A `VersionedIOReadableWritable` which allows to differentiate whether the previous data was versioned with a `VersionedIOReadableWritable`.
Preconditions	A collection of static utility methods to validate input.
PrimitiveArrayComparator<T,C extends BasicTypeComparator>
PrimitiveArrayTypeInfo<T>	A `TypeInformation` for arrays of primitive types (int, long, double, ...).
PrintSinkOutputWriter<IN>	Print sink output writer for DataStream and DataSet print API.
ProcessingTimeService	A service that allows to get the current processing time and register timers that will execute the given `ProcessingTimeService.ProcessingTimeCallback` when firing.
ProcessingTimeService.ProcessingTimeCallback	A callback that can be registered via `ProcessingTimeService.registerTimer(long, ProcessingTimeCallback)`.
ProcessorArchitecture	The processor architecture of the this system.
ProcessorArchitecture.MemoryAddressSize	The memory address size of the processor.
ProgramDescription	Implementing this interface allows a Program to have a description of the plan which can be shown to the user.
PropertiesUtil	Simple utilities for getting typed values from Properties.
QuadConsumer<S,T,U,V>	Operation which is performed on four given arguments.
QuadFunction<S,T,U,V,R>	Function which takes three arguments.
QueryableStateOptions	Deprecated. The Queryable State feature is deprecated since Flink 1.18, and will be removed in a future Flink major version.
RangeBoundaries<T>	RangeBoundaries is used to split the records into multiple ranges.
RateLimitedSourceReader<E,SplitT extends SourceSplit>	Wraps the actual `SourceReader` and rate limits its data emission.
RateLimiter	The interface to rate limit execution of methods.
RateLimiterStrategy	A factory for `RateLimiters` which apply rate-limiting to a source sub-task.
ReadableConfig	Read access to a configuration object.
ReaderInfo	A container class hosting the information of a `SourceReader`.
ReaderOutput<T>	The interface provided by the Flink runtime to the `SourceReader` to emit records, and optionally watermarks, to downstream operators for message processing.
ReadOnlyBroadcastState<K,V>	A read-only view of the `BroadcastState`.
Record	The Record represents a multi-valued data record.
RecordTimestampAssigner<E>	A `TimestampAssigner` that forwards the already-assigned timestamp.
RecoverableFsDataOutputStream	An output stream to a file system that can be recovered at well defined points.
RecoverableFsDataOutputStream.Committer	A committer can publish the file of a stream that was closed.
RecoverableWriter	The RecoverableWriter creates and recovers `RecoverableFsDataOutputStream`.
RecoverableWriter.CommitRecoverable	A handle to an in-progress stream with a defined and persistent amount of data.
RecoverableWriter.ResumeRecoverable	A handle to an in-progress stream with a defined and persistent amount of data.
ReduceFunction<T>	Base interface for Reduce functions.
ReduceOperatorBase<T,FT extends ReduceFunction<T>>	Base data flow operator for Reduce user-defined functions.
ReduceOperatorBase.CombineHint	An enumeration of hints, optionally usable to tell the system exactly how to execute the combiner phase of a reduce.
ReducingState<T>	`State` interface for reducing state.
ReducingStateDescriptor<T>	`StateDescriptor` for `ReducingState`.
RefCounted	Interface to simply add reference counting functionality.
RefCountedBufferingFileStream	A `RefCountedFileWithStream` that also uses an in-memory buffer for buffering small writes.
RefCountedFile	A reference counted file which is deleted as soon as no caller holds a reference to the wrapped `File`.
RefCountedFileWithStream	A reference counted file which is deleted as soon as no caller holds a reference to the wrapped `File`.
RefCountedFSOutputStream	A `FSDataOutputStream` with the `RefCounted` functionality.
RefCountedTmpFileCreator	A utility class that creates local `reference counted files` that serve as temporary files.
Reference<T>	Wrapper class that allows to express whether the value is borrowed or owned.
ReflectionUtil	Utility for reflection operations on classes and generic type parametrization.
ReflectionUtil.FullTypeInfo	Container for the full type information of a type.
ReplicatingInputFormat<OT,S extends InputSplit>	A ReplicatingInputFormat replicates any `InputFormat` to all parallel instances of a DataSource, i.e., the full input of the replicated InputFormat is completely processed by each parallel instance of the DataSource.
ReplicatingInputSplitAssigner	Assigns each InputSplit to each requesting parallel instance.
ResettableValue<T extends Value>
Resource<T extends Resource<T>>	Base class for resources one can specify.
ResourceGuard	This class is a guard for shared resources with the following invariants.
ResourceManagerOptions	The set of configuration options relating to the ResourceManager.
ResourceSpec	Describe the different resource factors of the operator with UDF.
ResourceSpec.Builder	Builder for the `ResourceSpec`.
RestartStrategies	This class defines methods to generate RestartStrategyConfigurations.
RestartStrategies.ExponentialDelayRestartStrategyConfiguration	Configuration representing an exponential delay restart strategy.
RestartStrategies.FailureRateRestartStrategyConfiguration	Configuration representing a failure rate restart strategy.
RestartStrategies.FallbackRestartStrategyConfiguration	Restart strategy configuration that could be used by jobs to use cluster level restart strategy.
RestartStrategies.FixedDelayRestartStrategyConfiguration	Configuration representing a fixed delay restart strategy.
RestartStrategies.NoRestartStrategyConfiguration	Configuration representing no restart strategy.
RestartStrategies.RestartStrategyConfiguration	Abstract configuration for restart strategies.
RestartStrategyOptions	Config options for restart strategies.
RestOptions	Configuration parameters for REST communication.
ResultTypeQueryable<T>	This interface can be implemented by functions and input formats to tell the framework about their produced data type.
RetryStrategy	Interface that encapsulates retry logic.
RichAggregateFunction<IN,ACC,OUT>	Rich variant of the `AggregateFunction`.
RichCoGroupFunction<IN1,IN2,OUT>	Rich variant of the `CoGroupFunction`.
RichCrossFunction<IN1,IN2,OUT>	Rich variant of the `CrossFunction`.
RichFilterFunction<T>	Rich variant of the `FilterFunction`.
RichFlatJoinFunction<IN1,IN2,OUT>	Rich variant of the `FlatJoinFunction`.
RichFlatMapFunction<IN,OUT>	Rich variant of the `FlatMapFunction`.
RichFunction	An base interface for all rich user-defined functions.
RichGroupCombineFunction<IN,OUT>	Rich variant of the `GroupCombineFunction`.
RichGroupReduceFunction<IN,OUT>	Rich variant of the `GroupReduceFunction`.
RichInputFormat<OT,T extends InputSplit>	An abstract stub implementation for Rich input formats.
RichJoinFunction<IN1,IN2,OUT>	Rich variant of the `JoinFunction`.
RichMapFunction<IN,OUT>	Rich variant of the `MapFunction`.
RichMapPartitionFunction<I,O>	Rich variant of the `MapPartitionFunction`.
RichOutputFormat<IT>	An abstract stub implementation for Rich output formats.
RichReduceFunction<T>	Rich variant of the `ReduceFunction`.
Row	A row is a fixed-length, null-aware composite type for storing multiple values in a deterministic field order.
RowComparator	Comparator for `Row`.
RowKind	Lists all kinds of changes that a row can describe in a changelog.
RowSerializer	Serializer for `Row`.
RowSerializer.RowSerializerSnapshot	A `TypeSerializerSnapshot` for RowSerializer.
RowTypeInfo	`TypeInformation` for `Row`.
RowUtils	Utilities to deal with `Row` instances.
RunnableWithException	Similar to a `Runnable`, this interface is used to capture a block of code to be executed.
RuntimeComparatorFactory<T>
RuntimeContext	A RuntimeContext contains information about the context in which functions are executed.
RuntimeContextInitializationContextAdapters	A set of adapters between `RuntimeContext` and `DeserializationSchema.InitializationContext` or `SerializationSchema.InitializationContext`.
RuntimeExecutionMode	Runtime execution mode of DataStream programs.
RuntimePairComparatorFactory<T1,T2>
RuntimeSerializerFactory<T>
RuntimeUDFContext	A standalone implementation of the `RuntimeContext`, created by runtime UDF operators.
SafetyNetCloseableRegistry	This implementation of an `AbstractAutoCloseableRegistry` registers `WrappingProxyCloseable`.
SafetyNetWrapperFileSystem	This is a `WrappingProxy` around `FileSystem` which (i) wraps all opened streams as `ClosingFSDataInputStream` or `ClosingFSDataOutputStream` and (ii) registers them to a `SafetyNetCloseableRegistry`.
SameTypePairComparator<T>
SavepointFormatType	Describes the binary format in which a savepoint should be taken.
ScheduledExecutor	Extension for the `Executor` interface which is enriched by method for scheduling tasks in the future.
ScheduledExecutorServiceAdapter	Adapter class for a `ScheduledExecutorService` which shall be used as a `ScheduledExecutor`.
SchedulerExecutionMode	Enum for controlling whether REACTIVE mode is enabled or not.
SecurityOptions	The set of configuration options relating to security.
SeekableDataInputView	Interface marking a `DataInputView` as seekable.
SeekableDataOutputView	Interface marking a `DataOutputView` as seekable.
SemanticProperties	Container for the semantic properties associated to an operator.
SemanticProperties.EmptySemanticProperties
SemanticProperties.InvalidSemanticAnnotationException
SeparateThreadExecutor	An `Executor` that runs every runnable in a separate thread.
SerializableFunction<T,R>	A `Function` that is also `Serializable`.
SerializableObject	A simple object that only implements `Serializable`, so it can be used in serializable classes.
SerializableOptional<T extends Serializable>	Serializable `Optional`.
SerializableSupplier<T>	A serializable `Supplier`.
SerializableSupplierWithException<T,E extends Throwable>	A serializable `SupplierWithException`.
SerializableTimestampAssigner<T>	A `TimestampAssigner` that is also `Serializable`.
SerializationSchema<T>	The serialization schema describes how to turn a data object into a different serialized representation.
SerializationSchema.InitializationContext	A contextual information provided for `SerializationSchema.open(InitializationContext)` method.
SerializedInputFormat<T extends IOReadableWritable>	Reads elements by deserializing them with their regular serialization/deserialization functionality.
SerializedListAccumulator<T>	This accumulator stores a collection of objects in serialized form, so that the stored objects are not affected by modifications to the original objects.
SerializedOutputFormat<T extends IOReadableWritable>	Stores elements by serializing them with their regular serialization/deserialization functionality.
SerializedThrowable	Utility class for dealing with user-defined Throwable types that are serialized (for example during RPC/Actor communication), but cannot be resolved with the default class loader.
SerializedValue<T>	This class is used to transfer (via serialization) objects whose classes are not available in the system class loader.
Serializers	Class containing utilities for the serializers of the Flink Runtime.
Serializers.DummyAvroKryoSerializerClass<T>	This is used in case we don't have Avro on the classpath.
Serializers.DummyAvroRegisteredClass	This is used in case we don't have Avro on the classpath.
Serializers.SpecificInstanceCollectionSerializer<T extends Collection>	Special serializer for Java collections enforcing certain instance types.
Serializers.SpecificInstanceCollectionSerializerForArrayList	Special serializer for Java's `ArrayList` used for Avro's GenericData.Array.
ShortComparator
ShortParser	Parses a decimal text field into a `Short`.
ShortPrimitiveArrayComparator
ShortPrimitiveArraySerializer	A serializer for short arrays.
ShortPrimitiveArraySerializer.ShortPrimitiveArraySerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
ShortSerializer	Type serializer for `Byte`.
ShortSerializer.ShortSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
ShortValue	Boxed serializable and comparable short integer type, representing the primitive type `short`.
ShortValueComparator	Specialized comparator for ShortValue based on CopyableValueComparator.
ShortValueParser	Parses a decimal text field into a `ShortValue`.
ShortValueSerializer
ShortValueSerializer.ShortValueSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
ShutdownHookUtil	Utils class for dealing with JVM shutdown hooks.
SimpleAccumulator<T extends Serializable>	Similar to Accumulator, but the type of items to add and the result value must be the same.
SimpleStringEncoder<IN>	A simple `Encoder` that uses `toString()` on the input elements and writes them to the output bucket file separated by newline.
SimpleStringSchema	Very simple serialization schema for strings.
SimpleTypeSerializerSnapshot<T>	A simple base class for TypeSerializerSnapshots, for serializers that have no parameters.
SimpleUserCodeClassLoader	Simple `UserCodeClassLoader` implementation which assumes that the provided class loader will never be released and, hence, will never execute the release hooks.
SimpleVersionedSerialization	Simple serialization / deserialization methods for the `SimpleVersionedSerializer`.
SimpleVersionedSerializer<E>	A simple serializer interface for versioned serialization.
SimpleVersionedSerializerTypeSerializerProxy<T>	A `TypeSerializer` that delegates to an underlying `SimpleVersionedSerializer`.
SingleInputOperator<IN,OUT,FT extends Function>	Abstract superclass for all operators that have one input like "map" or "reduce".
SingleInputSemanticProperties	Container for the semantic properties associated to a single input operator.
SingleInputSemanticProperties.AllFieldsForwardedProperties
SingleThreadAccessCheckingTypeSerializer<T>
SingleThreadAccessCheckingTypeSerializer.SingleThreadAccessCheckingTypeSerializerSnapshot<T>
Sink<InputT,CommT,WriterStateT,GlobalCommT>	Deprecated. Please use `Sink` or a derivative.
Sink<InputT>	Base interface for developing a sink.
Sink.InitContext	Deprecated. Please migrate to `Sink` and use `Sink.InitContext`.
Sink.InitContext	The interface exposes some runtime info for creating a `SinkWriter`.
Sink.ProcessingTimeService	Deprecated. Please migrate to `Sink` and use `ProcessingTimeService`.
Sink.ProcessingTimeService.ProcessingTimeCallback	Deprecated. Please migrate to `Sink` and use `ProcessingTimeService.ProcessingTimeCallback`.
SinkUtils	Utility class for sinks.
SinkWriter<InputT,CommT,WriterStateT>	Deprecated. Please use `SinkWriter` or a derivative.
SinkWriter<InputT>	The `SinkWriter` is responsible for writing data.
SinkWriter.Context	Deprecated. Please migrate to `SinkWriter` and use `SinkWriter.Context`.
SinkWriter.Context	Context that `SinkWriter.write(InputT, org.apache.flink.api.connector.sink2.SinkWriter.Context)` can use for getting additional data about an input record.
SlotSharingGroup	Describe the name and the different resource components of a slot sharing group.
SlotSharingGroup.Builder	Builder for the `SlotSharingGroup`.
SlotSharingGroupUtils	Utils for `SlotSharingGroup`.
SlowTaskDetectorOptions	Configuration options to detect slow tasks.
SortPartitionOperatorBase<IN>
Source<T,SplitT extends SourceSplit,EnumChkT>	The interface for Source.
SourceEvent	An base class for the events passed between the SourceReaders and Enumerators.
SourceOutput<T>	The `SourceOutput` is the gateway for a `SourceReader`) to emit the produced records and watermarks.
SourceReader<T,SplitT extends SourceSplit>	The interface for a source reader which is responsible for reading the records from the source splits assigned by `SplitEnumerator`.
SourceReaderContext	The interface that exposes some context from runtime to the `SourceReader`.
SourceReaderFactory<T,SplitT extends SourceSplit>	A factory for creating source reader instances.
SourceSplit	An interface for all the Split types to extend.
SplitEnumerator<SplitT extends SourceSplit,CheckpointT>	The interface for a split enumerator responsible for discovering the source splits, and assigning them to the `SourceReader`.
SplitEnumeratorContext<SplitT extends SourceSplit>	A context class for the `SplitEnumerator`.
SplitsAssignment<SplitT extends SourceSplit>	A class containing the splits assignment to the source readers.
SplittableIterator<T>	Abstract base class for iterators that can split themselves into multiple disjoint iterators.
SqlDateParser	Parses a text field into a `Date`.
SqlDateSerializer
SqlDateSerializer.SqlDateSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
SqlTimeParser	Parses a text field into a `Time`.
SqlTimeSerializer
SqlTimeSerializer.SqlTimeSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
SqlTimestampComparator	Comparator for comparing Java SQL Timestamps.
SqlTimestampParser	Parses a text field into a `Timestamp`.
SqlTimestampSerializer
SqlTimestampSerializer.SqlTimestampSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
SqlTimeTypeInfo<T>	Type information for Java SQL Date/Time/Timestamp.
State	Interface that different types of partitioned state must implement.
StateBackendOptions	A collection of all configuration options that relate to state backend.
StateChangelogOptions	A collection of all configuration options that relate to changelog.
StateChangelogOptionsInternal	StateChangelog options that are used to pass job-level configuration from JM to TM.
StateDescriptor<S extends State,T>	Base class for state descriptors.
StateDescriptor.Type	An enumeration of the types of supported states.
StatefulSink<InputT,WriterStateT>	A `Sink` with a stateful `SinkWriter`.
StatefulSink.StatefulSinkWriter<InputT,WriterStateT>	A `SinkWriter` whose state needs to be checkpointed.
StatefulSink.WithCompatibleState	A mix-in for `StatefulSink` that allows users to migrate from a sink with a compatible state to this sink.
StateMigrationException	Base class for state migration related exceptions.
StateTtlConfig	Configuration of state TTL logic.
StateTtlConfig.Builder	Builder for the `StateTtlConfig`.
StateTtlConfig.CleanupStrategies	TTL cleanup strategies.
StateTtlConfig.IncrementalCleanupStrategy	Configuration of cleanup strategy while taking the full snapshot.
StateTtlConfig.RocksdbCompactFilterCleanupStrategy	Configuration of cleanup strategy using custom compaction filter in RocksDB.
StateTtlConfig.StateVisibility	This option configures whether expired user value can be returned or not.
StateTtlConfig.TtlTimeCharacteristic	This option configures time scale to use for ttl.
StateTtlConfig.UpdateType	This option value configures when to update last access timestamp which prolongs state TTL.
StringArraySerializer	A serializer for String arrays.
StringArraySerializer.StringArraySerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
StringBasedID	Base class for typed IDs that are internally represented by a string.
StringComparator
StringParser	Converts a variable length field of a byte array into a `String`.
StringSerializer	Type serializer for `String`.
StringSerializer.StringSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
StringUtils	Utility class to convert objects into strings in vice-versa.
StringValue	Mutable string data type that implements the Key interface.
StringValueComparator	Specialized comparator for StringValue based on CopyableValueComparator.
StringValueParser	Converts a variable length field of a byte array into a `StringValue`.
StringValueSerializer
StringValueSerializer.StringValueSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
StringValueUtils	Utility class for efficient operations on `StringValue`.
StringValueUtils.WhitespaceTokenizer	A tokenizer for string values that uses whitespace characters as token delimiters.
SubmoduleClassLoader	Loads all classes from the submodule jar, except for explicitly white-listed packages.
SupplierWithException<R,E extends Throwable>	A functional interface for a `Supplier` that may throw exceptions.
SupportsConcurrentExecutionAttempts	The interface indicates that it supports multiple attempts executing at the same time.
SupportsHandleExecutionAttemptSourceEvent	An decorative interface of `SplitEnumerator` which allows to handle `SourceEvent` sent from a specific execution attempt.
SupportsIntermediateNoMoreSplits	A decorative interface of `SplitEnumeratorContext` which allows to handle intermediate NoMoreSplits.
SystemClock	A clock that returns the time of the system / process.
TaskInfo	Encapsulates task-specific information: name, index of subtask, parallelism and attempt number.
TaskManagerExceptionUtils	Exception utils to handle and enrich exceptions occurring in TaskManager.
TaskManagerOptions	The set of configuration options relating to TaskManager and Task settings.
TaskManagerOptionsInternal	TaskManager options that are not meant to be used by the user.
TemporaryClassLoaderContext	Sets a context class loader in a "try-with-resources" pattern.
TernaryBoolean	A ternary boolean, which can have the values 'true', 'false', or 'undefined'.
TextElement	Represents a text block in the `Description`.
TextElement.TextStyle	Styles that can be applied to `TextElement` e.g.
ThreadUtils	`ThreadUtils` collects helper methods in the context of threading.
ThrowableCatchingRunnable	This class catches all the `Throwables` from the wrapped runnable.
ThrowingConsumer<T,E extends Throwable>	This interface is basically Java's `Consumer` interface enhanced with the ability to throw an exception.
ThrowingRunnable<E extends Throwable>	Similar to a `Runnable`, this interface is used to capture a block of code to be executed.
Time	The definition of a time interval.
TimestampAssigner<T>	A `TimestampAssigner` assigns event time timestamps to elements.
TimestampAssignerSupplier<T>	A supplier for `TimestampAssigners`.
TimestampAssignerSupplier.Context	Additional information available to `TimestampAssignerSupplier.createTimestampAssigner(Context)`.
TimestampAssignerSupplier.SupplierFromSerializableTimestampAssigner<T>	We need an actual class.
TimeUtils	Collection of utilities about time intervals.
Transformation<T>	A `Transformation` represents the operation that creates a DataStream.
TraversableOnceException	An exception, indicating that an `Iterable` can only be traversed once, but has been attempted to traverse an additional time.
TriConsumer<S,T,U>	Operation which is performed on three given arguments.
TriConsumerWithException<S,T,U,E extends Throwable>	A checked extension of the `TriConsumer` interface.
TriFunction<S,T,U,R>	Function which takes three arguments.
TriFunctionWithException<S,T,U,R,E extends Throwable>	Function which takes three arguments.
Tuple	The base class of all tuples.
Tuple0	A tuple with 0 fields.
Tuple0Builder	A builder class for `Tuple0`.
Tuple0Serializer
Tuple0SerializerSnapshot	A `TypeSerializerSnapshot` for `Tuple0Serializer`.
Tuple1<T0>	A tuple with 1 fields.
Tuple10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>	A tuple with 10 fields.
Tuple10Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>	A builder class for `Tuple10`.
Tuple11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>	A tuple with 11 fields.
Tuple11Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>	A builder class for `Tuple11`.
Tuple12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>	A tuple with 12 fields.
Tuple12Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>	A builder class for `Tuple12`.
Tuple13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>	A tuple with 13 fields.
Tuple13Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>	A builder class for `Tuple13`.
Tuple14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>	A tuple with 14 fields.
Tuple14Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>	A builder class for `Tuple14`.
Tuple15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>	A tuple with 15 fields.
Tuple15Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>	A builder class for `Tuple15`.
Tuple16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>	A tuple with 16 fields.
Tuple16Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>	A builder class for `Tuple16`.
Tuple17<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>	A tuple with 17 fields.
Tuple17Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>	A builder class for `Tuple17`.
Tuple18<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>	A tuple with 18 fields.
Tuple18Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>	A builder class for `Tuple18`.
Tuple19<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>	A tuple with 19 fields.
Tuple19Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>	A builder class for `Tuple19`.
Tuple1Builder<T0>	A builder class for `Tuple1`.
Tuple2<T0,T1>	A tuple with 2 fields.
Tuple20<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>	A tuple with 20 fields.
Tuple20Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>	A builder class for `Tuple20`.
Tuple21<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>	A tuple with 21 fields.
Tuple21Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>	A builder class for `Tuple21`.
Tuple22<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>	A tuple with 22 fields.
Tuple22Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>	A builder class for `Tuple22`.
Tuple23<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>	A tuple with 23 fields.
Tuple23Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>	A builder class for `Tuple23`.
Tuple24<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23>	A tuple with 24 fields.
Tuple24Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23>	A builder class for `Tuple24`.
Tuple25<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24>	A tuple with 25 fields.
Tuple25Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24>	A builder class for `Tuple25`.
Tuple2Builder<T0,T1>	A builder class for `Tuple2`.
Tuple3<T0,T1,T2>	A tuple with 3 fields.
Tuple3Builder<T0,T1,T2>	A builder class for `Tuple3`.
Tuple4<T0,T1,T2,T3>	A tuple with 4 fields.
Tuple4Builder<T0,T1,T2,T3>	A builder class for `Tuple4`.
Tuple5<T0,T1,T2,T3,T4>	A tuple with 5 fields.
Tuple5Builder<T0,T1,T2,T3,T4>	A builder class for `Tuple5`.
Tuple6<T0,T1,T2,T3,T4,T5>	A tuple with 6 fields.
Tuple6Builder<T0,T1,T2,T3,T4,T5>	A builder class for `Tuple6`.
Tuple7<T0,T1,T2,T3,T4,T5,T6>	A tuple with 7 fields.
Tuple7Builder<T0,T1,T2,T3,T4,T5,T6>	A builder class for `Tuple7`.
Tuple8<T0,T1,T2,T3,T4,T5,T6,T7>	A tuple with 8 fields.
Tuple8Builder<T0,T1,T2,T3,T4,T5,T6,T7>	A builder class for `Tuple8`.
Tuple9<T0,T1,T2,T3,T4,T5,T6,T7,T8>	A tuple with 9 fields.
Tuple9Builder<T0,T1,T2,T3,T4,T5,T6,T7,T8>	A builder class for `Tuple9`.
TupleComparator<T extends Tuple>
TupleComparatorBase<T>
TupleSerializer<T extends Tuple>
TupleSerializerBase<T>
TupleSerializerSnapshot<T extends Tuple>	Snapshot of a tuple serializer's configuration.
TupleTypeInfo<T extends Tuple>	A `TypeInformation` for the tuple types of the Java API.
TupleTypeInfoBase<T>
TwoPhaseCommittingSink<InputT,CommT>	A `Sink` for exactly-once semantics using a two-phase commit protocol.
TwoPhaseCommittingSink.PrecommittingSinkWriter<InputT,CommT>	A `SinkWriter` that performs the first part of a two-phase commit protocol.
TypeComparable<T>	Wrapper that is used to store elements for which we have a TypeComparator in a Hash Map.
TypeComparator<T>	This interface describes the methods that are required for a data type to be handled by the pact runtime.
TypeComparatorFactory<T>
TypeExtractionException	Type extraction always contains some uncertainty due to unpredictable JVM differences between vendors or versions.
TypeExtractionUtils
TypeExtractionUtils.LambdaExecutable	Similar to a Java 8 Executable but with a return type.
TypeExtractor	A utility for reflection analysis on classes, to determine the return type of implementations of transformation functions.
TypeHint<T>	A utility class for describing generic types.
TypeInfo	Annotation for specifying a corresponding `TypeInfoFactory` that can produce `TypeInformation` for the annotated type.
TypeInfoFactory<T>	Base class for implementing a type information factory.
TypeInformation<T>	TypeInformation is the core class of Flink's type system.
TypeInformationSerializationSchema<T>	A serialization and deserialization schema that uses Flink's serialization stack to transform typed from and to byte arrays.
TypePairComparator<T1,T2>	This interface defines the method required by the runtime to use data types in join-like operations.
TypePairComparatorFactory<T1,T2>
Types	This class gives access to the type information of the most common types for which Flink has built-in serializers and comparators.
TypeSerializer<T>	This interface describes the methods that are required for a data type to be handled by the Flink runtime.
TypeSerializerFactory<T>
TypeSerializerSchemaCompatibility<T>	A `TypeSerializerSchemaCompatibility` represents information about whether or not a `TypeSerializer` can be safely used to read data written by a previous type serializer.
TypeSerializerSingleton<T>
TypeSerializerSnapshot<T>	A `TypeSerializerSnapshot` is a point-in-time view of a `TypeSerializer`'s configuration.
TypeSerializerSnapshotSerializationUtil	Utility methods for serialization of `TypeSerializerSnapshot`.
TypeSerializerUtils	Utilities for dealing with the `TypeSerializer` and the `TypeSerializerSnapshot`.
UnaryOperatorInformation<IN,OUT>	A class for holding information about a single input operator, such as input/output TypeInformation.
Union<T>	This operator represents a Union between two inputs.
UnionIterator<T>	An iterator that concatenates a collection of iterators.
UnloadableDummyTypeSerializer<T>	Dummy TypeSerializer to avoid that data is lost when checkpointing again a serializer for which we encountered a `ClassNotFoundException` or `InvalidClassException`.
UnmodifiableConfiguration	Unmodifiable version of the Configuration class.
UnsupportedFileSystemSchemeException	An exception to indicate that a specific file system scheme is not supported.
UserCodeClassLoader	UserCodeClassLoader allows to register release hooks for a user code class loader.
UserCodeClassWrapper<T>	This holds a class containing user defined code.
UserCodeObjectWrapper<T>	This holds an actual object containing user defined code.
UserCodeWrapper<T>	UDf operators can have either a class or an object containing the user code, this is the common interface to access them.
UserSystemExitException	Indicates that user tried to exit JVM.
Value	Basic value interface for types that act as serializable values.
ValueComparator<T extends Value & Comparable<T>>	Comparator for all Value types that extend Key
ValueSerializer<T extends Value>	Serializer for `Value` types.
ValueSerializer.ValueSerializerSnapshot<T extends Value>	`ValueSerializer` snapshot class.
ValueState<T>	`State` interface for partitioned single-value state.
ValueStateDescriptor<T>	`StateDescriptor` for `ValueState`.
ValueTypeInfo<T extends Value>	Type information for data types that extend the `Value` interface.
Versioned	This interface is implemented by classes that provide a version number.
VersionedIOReadableWritable	This is the abstract base class for `IOReadableWritable` which allows to differentiate between serialization versions.
VersionMismatchException	This exception signals that incompatible versions have been found during serialization.
Visitable<T extends Visitable<T>>	This interface marks types as visitable during a traversal.
Visitor<T extends Visitable<T>>	A visitor encapsulates functionality that is applied to each node in the process of a traversal of a tree or DAG.
VoidSerializer	Serializer for `Void`.
VoidSerializer.VoidSerializerSnapshot	Serializer configuration snapshot for compatibility and format evolution.
Watermark	Watermarks are the progress indicators in the data streams.
WatermarkAlignmentParams	Configuration parameters for watermark alignment.
WatermarkGenerator<T>	The `WatermarkGenerator` generates watermarks either based on events or periodically (in a fixed interval).
WatermarkGeneratorSupplier<T>	A supplier for `WatermarkGenerators`.
WatermarkGeneratorSupplier.Context	Additional information available to `WatermarkGeneratorSupplier.createWatermarkGenerator(Context)`.
WatermarkOutput	An output for watermarks.
WatermarkOutputMultiplexer	A `WatermarkOutputMultiplexer` combines the watermark (and idleness) updates of multiple partitions/shards/splits into one combined watermark update and forwards it to an underlying `WatermarkOutput`.
WatermarkOutputMultiplexer.WatermarkUpdateListener	A callback for propagating changes to split based watermarks.
WatermarkStrategy<T>	The WatermarkStrategy defines how to generate `Watermark`s in the stream sources.
WatermarksWithIdleness<T>	A WatermarkGenerator that adds idleness detection to another WatermarkGenerator.
WebOptions	Configuration options for the WebMonitorEndpoint.
WrappingProxy<T>	Interface for objects that wrap another object and proxy (possibly a subset) of the methods of that object.
WrappingProxyCloseable<T extends Closeable>	`WrappingProxy` for `Closeable` that is also closeable.
WrappingProxyUtil	Utilities for working with `WrappingProxy`.
WrappingRuntimeException	A runtime exception that is explicitly used to wrap non-runtime exceptions.
WritableConfig	Write access to a configuration object.
XORShiftRandom	Implement a random number generator based on the XORShift algorithm discovered by George Marsaglia.
XZInputStreamFactory	Factory for XZ decompressors.
ZStandardInputStreamFactory	Factory for ZStandard decompressors.