All Classes and Interfaces

Class	Description
AbstractBundledDependenciesNoticeTest	Keeps a flink-sql-connector-gcp-* module's META-INF/NOTICE honest: it must list every artifact the uber-jar bundles, and nothing it does not.
AbstractSqlConnectorPackagingITCase	Asserts the shape of a flink-sql-connector-gcp-* uber-jar: that SQL can discover the connector in it, that every runtime dependency actually made it in, and that no class escaped relocation except those that deliberately did.
AbstractSqlConnectorSmokeITCase	The precondition every flink-sql-connector-gcp-* smoke test rests on: that the connector it just exercised came out of the uber-jar.
AckHandle	Settles one delivered message, hiding which of the client library's two receiver flavors produced it.
AckTracker	Tracks the acknowledgement lifecycle of received Pub/Sub messages, which is what makes the source at-least-once.
AdditionalField<T>	One physical BigQuery column appended after the configured serializer emits a row.
AdditionalFieldNullPolicy	Determines how an additional physical field handles a provider returning null.
AdditionalFields<T>	Ordered physical fields appended to every destination row and table schema.
AdditionalFields.Builder<T>	Builder for AdditionalFields.
AdditionalFieldType	Supported BigQuery types for singular additional physical fields.
AdditionalFieldValueProvider<T>	Extracts one additional physical-field value from the original input record.
AppendErrorClassifier	Classifies Storage Write API append failures into the error classes the writer routes on.
AppEngineTargetBuilder<T>	Builds an immutable AppEngineTargetSerializationSchema.
AppEngineTargetBuilder.HeadersExtractor<T>	Extracts App Engine request headers from a record.
AppEngineTargetBuilder.RelativeUriExtractor<T>	Extracts the App Engine relative URI from a record.
AppEngineTargetBuilder.RoutingExtractor<T>	Extracts App Engine service, version, and instance routing from a sink record.
AppEngineTargetChecks	Checks and normalizes App Engine request fields shared by all sink APIs.
AppEngineTargetSerializationSchema<T>	A CloudTasksSerializationSchema producing App Engine target tasks.
AppEngineTargetSpec	Validated fixed App Engine request values used by the table serializer.
AvroRecordSerializationSchema	A BigQueryProtoSerializationSchema for Avro records.
AvroRowConverter	Converts Avro records into the protobuf rows the BigQuery Storage Write API accepts, against the schema AvroToTableSchemaConverter derived and the descriptor BQTableSchemaToProtoDescriptor built from it.
AvroSchemaOptions	Options controlling how Avro schemas are mapped to BigQuery schemas.
AvroSchemaOptions.Builder	Builder for AvroSchemaOptions.
AvroToTableSchemaConverter	Derives a BigQuery TableSchema from an Avro Schema.
Awaits	Deadline-bounded polling for test assertions.
BatchClientPartitionPlanner	Plans a read through a google-cloud-spanner BatchClient.
BatchClientStructStreamOpener	Reads partitions through a google-cloud-spanner BatchClient.
BatchReadSplit	One partition of a batch read, together with the snapshot it belongs to.
BatchReadSplitSerializer	Serializer for BatchReadSplit.
BatchReadSplitState	The mutable reader-side state of a BatchReadSplit.
BigQueryBufferedStreamSink<T>	The WriteMethod.STORAGE_API_EXACTLY_ONCE sink: each writer subtask appends rows to one application-created BUFFERED Storage Write API stream per active destination at explicit offsets (see BigQueryBufferedStreamWriter), and the committer makes each completed checkpoint's rows visible by flushing every committable's stream up to its offset (see BufferedStreamCommitter) — two-phase commit on Flink checkpoints.
BigQueryBufferedStreamWriter<T>	Exactly-once SinkWriter appending rows to one application-created BUFFERED Storage Write API stream per destination at explicit offsets.
BigQueryConnectorOptions	The WITH options of the bigquery table connector.
BigQueryCredentials	Loads credentials shared by the BigQuery and Cloud Storage client families.
BigQueryDefaultStreamSink<T>	At-least-once sink appending to Storage Write API default streams with dynamic per-record table destinations (WriteMethod.STORAGE_API_AT_LEAST_ONCE).
BigQueryDefaultStreamWriter<T>	At-least-once SinkWriter appending to Storage Write API default streams with dynamic per-record table destinations.
BigQueryDynamicSink	The bigquery table sink.
BigQueryDynamicSink.Builder	Collects the sink's fully resolved values.
BigQueryDynamicSource	A bounded Table API source mapped onto BigQuerySource.
BigQueryDynamicSource.Builder	Collects the source's fully resolved values.
BigQueryDynamicTableFactory	Creates the bigquery table source or sink from a CREATE TABLE statement's options.
BigQueryEmulatorContainers	The BigQuery emulator image and its two endpoints, shared by every harness that starts the emulator so they cannot drift apart.
BigQueryFailure	A record-specific BigQuery sink failure handled by the configured failure policy.
BigQueryFileLoadsSink<T>	The WriteMethod.FILE_LOADS sink: writers stage per-destination files on Cloud Storage in the configured staging format, the pre-commit topology routes every subtask's committables to a single committer subtask (stamping their checkpoint id in streaming, see FileLoadsCheckpointStamper), and the committer turns each batch into BigQuery load jobs (see FileLoadsCommitter and LoadJobOrchestrator) — the whole run at end of input in batch execution, each checkpoint's files at its completion in streaming execution.
BigQueryLoadJobRunner	LoadJobRunner over the BigQuery REST client with configured credentials or ADC.
BigQueryLoadJobRunner.SharedJobs	Thread-safe submitted-job state shared by every worker of one committer.
BigQueryMetricNames	Every metric name this connector registers itself, in one place so that this file is the connector's inventory: what it reports can be read here without opening a writer.
BigQueryProtoSerializationSchema<T>	Serializes records into protobuf rows to be written to BigQuery.
BigQueryQueryRunner	Runs the source's query through the REST BigQuery client.
BigQueryReadClients	Storage Read API clients, for the two places the source opens one: the enumerator creates the read session, and every reader opens its assigned streams.
BigQueryReadEnumeratorState	The enumerator's checkpointed state: whether the read session exists, which one it is, and the splits not currently assigned to a reader.
BigQueryReadEnumeratorStateSerializer	Serializer for BigQueryReadEnumeratorState.
BigQueryReadSplitEnumerator	Creates the read session once and hands its streams out one at a time.
BigQueryRecordEmitter<T>	Converts each row and advances the stream's offset by exactly one row after successful deserialization and downstream collection.
BigQueryRowDeserializationSchema<T>	Converts a row read from the BigQuery Storage Read API into zero or more output records.
BigQuerySchemaConverter	Converts a REST client Schema (as read from live tables) into the Storage API TableSchema form the sink's schema handling operates on.
BigQuerySink	Entry point for building a BigQuery sink.
BigQuerySinkBuilder<T>	Builder for BigQuery sinks, obtained from BigQuerySink.builder().
BigQuerySinkConfig<T>	Immutable configuration shared by all WriteMethod implementations, assembled by BigQuerySinkBuilder.
BigQuerySource	A bounded source reading a BigQuery table through the Storage Read API.
BigQuerySourceBuilder<T>	Builds a BigQuerySource.
BigQuerySourceConfig<T>	Everything the source's enumerator and readers were configured with, as one immutable object shipped inside the job graph.
BigQuerySourceReader<T>	Reader subtask consuming the read streams it is assigned, one at a time.
BigQuerySourceReaderMetrics	The reader's metrics.
BigQuerySplitReader	Reads the rows of the streams this subtask was assigned, a bounded batch at a time.
BigQueryStorageReadSource<T>	Reads a BigQuery table through the Storage Read API.
BigQueryTableAdmin	Default TableAdmin backed by the BigQuery REST client.
BigtableChangeStreamDeserializationSchema<T>	Turns one Bigtable change-stream mutation into zero or more user records.
BigtableChangeStreamDynamicSource	Table changelog source backed by the DataStream Change Streams source.
BigtableChangeStreamDynamicSource.Builder	Builds a BigtableChangeStreamDynamicSource.
BigtableChangeStreamEnumeratorState	Checkpointed coordinator state for the Bigtable Change Streams partition topology.
BigtableChangeStreamEnumeratorStateSerializer	Connector-owned checkpoint format for BigtableChangeStreamEnumeratorState.
BigtableChangeStreamEnvelopeSchema	The exact physical schema of the generic Bigtable Change Streams mutation envelope.
BigtableChangeStreamMutation	One complete logical row mutation returned by Bigtable Change Streams.
BigtableChangeStreamMutation.AddToCellEntry	Adds an aggregate input to one cell.
BigtableChangeStreamMutation.BoundType	How a BigtableChangeStreamMutation.TimestampBound constrains its end of the range: exclusive, inclusive, or not at all.
BigtableChangeStreamMutation.DeleteCellsEntry	Deletes cell versions in one timestamp range.
BigtableChangeStreamMutation.DeleteFamilyEntry	Deletes every cell in one family.
BigtableChangeStreamMutation.Entry	One ordered mutation entry.
BigtableChangeStreamMutation.EntryKind	Which subtype an BigtableChangeStreamMutation.Entry is.
BigtableChangeStreamMutation.Int64Value	A signed 64-bit integer in an aggregate entry.
BigtableChangeStreamMutation.MergeToCellEntry	Merges an aggregate input into one cell.
BigtableChangeStreamMutation.MutationType	What produced a mutation: a user write, or the table's garbage-collection policy.
BigtableChangeStreamMutation.RawTimestamp	A raw microsecond timestamp in an aggregate entry.
BigtableChangeStreamMutation.RawValue	Arbitrary bytes in an aggregate entry.
BigtableChangeStreamMutation.SetCellEntry	Writes one cell version.
BigtableChangeStreamMutation.TimestampBound	One timestamp-range boundary.
BigtableChangeStreamMutation.TimestampRange	Timestamp range affected by a cell deletion.
BigtableChangeStreamMutation.Value	One typed value used by an aggregate entry.
BigtableChangeStreamMutation.ValueType	Which subtype a BigtableChangeStreamMutation.Value is.
BigtableChangeStreamMutationDeserializationSchema	Emits the connector-owned BigtableChangeStreamMutation unchanged.
BigtableChangeStreamMutationFilter	The connector-side family and qualifier patterns, answering whether one identifier is retained.
BigtableChangeStreamMutationSerializer	Serializes the connector-owned mutation model without reflective collection access.
BigtableChangeStreamMutationSerializer.Snapshot	Snapshot for the connector-owned field format.
BigtableChangeStreamMutationTypeInfoFactory	Supplies the connector-owned serializer for BigtableChangeStreamMutation.
BigtableChangeStreamReader<T>	Reads a bounded number of Bigtable Change Streams partitions concurrently.
BigtableChangeStreamReaderMetrics	Reporter-visible state for one Bigtable Change Streams reader subtask.
BigtableChangeStreamRecordEmitter<T>	Emits mutations with commit timestamps and advances token/watermark state.
BigtableChangeStreamSource<T>	FLIP-27 source for Bigtable Change Streams.
BigtableChangeStreamSourceBuilder<T>	Builds a BigtableChangeStreamSource.
BigtableChangeStreamSourceConfig<T>	Everything the Change Streams source was built with, assembled by the builder and carried into the job graph.
BigtableChangeStreamSplitEnumerator	Coordinates Bigtable Change Streams partitions, split successors, and merge-parent tokens.
BigtableConnectorOptions	The WITH options of the bigtable table connector.
BigtableCredentials	Loads credentials for the Bigtable data and admin client families.
BigtableDataClients	How this connector points a BigtableDataClient at an instance: production over application-default credentials, production over a runtime-loaded service-account provider, or an emulator over a plaintext channel with no credentials.
BigtableDynamicSink	The bigtable table sink.
BigtableDynamicSink.Builder	Collects the sink's values, so no caller has to keep a positional list in order.
BigtableDynamicSource	The bigtable table source: a bounded scan over the DataStream BigtableSource and row-key point lookups through Bigtable's data client.
BigtableDynamicSource.Builder	Collects the source's values, so no caller has to keep a positional list in order.
BigtableDynamicTableFactory	Creates the bigtable table sink and table source from a CREATE TABLE statement's options.
BigtableEmulatorContainers	The Bigtable emulator image shared by every harness that starts the emulator, so they cannot drift apart.
BigtableLookupConfig	The lookup values a CREATE TABLE maps into the Bigtable table source.
BigtableMetricNames	Every metric name this connector registers itself, in one place so that this file is the connector's inventory: what it reports can be read here without opening the writer.
BigtableMutateRowsSink<T>	At-least-once sink applying one row mutation per record through the MutateRows bulk batcher of google-cloud-bigtable.
BigtableRecordEmitter<T>	Deserializes each row and records that the split has passed it.
BigtableRowDataAsyncLookupFunction	An asynchronous Bigtable row-key point lookup producing the table source's projected row.
BigtableRowDataLookupFunction	A synchronous Bigtable row-key point lookup producing the table source's projected row.
BigtableRowDeserializationSchema<T>	Turns a Bigtable row into the records a job works with.
BigtableScanEnumeratorState	What the split enumerator checkpoints: whether the table has been sampled and planned, and the splits nobody is holding yet.
BigtableScanEnumeratorStateSerializer	Serializer for BigtableScanEnumeratorState.
BigtableScanSource<T>	The bounded scan source over Bigtable's ReadRows.
BigtableScanSplitEnumerator	Samples the table once, cuts the configured ranges at the sampled boundaries, and hands the pieces out one at a time.
BigtableSerializationSchema<T>	Serializes sink records into Bigtable row mutations.
BigtableSink	Entry point for building a Bigtable sink.
BigtableSinkBuilder<T>	Builder for Bigtable sinks, obtained from BigtableSink.builder().
BigtableSinkConfig<T>	Immutable sink configuration assembled by BigtableSinkBuilder.
BigtableSource	Reads rows from a Cloud Bigtable table.
BigtableSourceBuilder<T>	Builds a BigtableSource.
BigtableSourceConfig<T>	Everything the scan source was built with, assembled by the builder and carried into the job graph.
BigtableSourceReader<T>	Reads the splits this subtask is assigned, asking the enumerator for the next one each time it finishes one.
BigtableSourceReaderMetrics	The scan reader's own counters, beside the ones Flink registers for every source.
BigtableSplitReader	Reads the row-key ranges this subtask was assigned, a bounded batch at a time.
BigtableTableAdmin	Default TableAdmin backed by the Bigtable BigtableTableAdminClient.
BigtableTableSchema	The DDL schema of a bigtable table: which column is the row key, and which column family and qualifier every other column addresses.
BigtableTableSchema.Family	One column family: a ROW column whose nested fields are its qualifiers.
BigtableTableSchema.Qualifier	One qualifier: a nested field of a column family's ROW.
BigtableTestClients	Stock Bigtable clients pointed at an emulator container.
BigtableWriter<T>	At-least-once writer applying row mutations to the Bigtable tables a DestinationResolver names.
BigtableWriterOptions	Tuning options for the sink's writer: the batch thresholds handed to the client, and the writer's own bounds on unacknowledged entries.
BigtableWriterOptions.Builder	Builder for BigtableWriterOptions.
BoundedShutdown	The teardown of one client whose own shutdown cannot be trusted to return: both of its steps on a separate thread, and one deadline that the calling thread's single join is the whole of.
BoundedShutdown.TerminationWait	The client's own bounded wait, satisfied by e.g.
BufferedStreamCommittable	A flush instruction for one buffered write stream: make every row up to flushOffset (inclusive, per FlushRows semantics) visible in the destination table.
BufferedStreamCommittableSerializer	Serializer for BufferedStreamCommittable.
BufferedStreamCommitter	Committer of the buffered-stream write path: makes each completed checkpoint's rows visible by flushing every committable's stream up to its offset (FlushRows).
BufferedStreamOptions	Options specific to WriteMethod.STORAGE_API_EXACTLY_ONCE: how large append requests may grow, how long inactive destinations stay cached, how the connector-driven recovery schedule backs off, and how the SDK retries retriable append failures in-stream.
BufferedStreamOptions.Builder	Builder for BufferedStreamOptions.
BufferedStreamOptionsMapper	Maps the sink.buffered-stream.* options onto BufferedStreamOptions.
BufferedStreamService	The Storage Write API operations of the buffered-stream write path, abstracted so writer and committer logic can be unit-tested against fakes: creating buffered streams, opening offset-aware appenders on them, and flushing rows.
BufferedStreamServiceFactory	Creates BufferedStreamService instances on the task manager.
BufferedStreamWriterState	One destination's buffered-stream writer state: which stream the subtask owns and how many rows it had appended (acknowledged) as of the checkpoint.
BufferedStreamWriterStateSerializer	Serializer for BufferedStreamWriterState.
BufferUsage	What one subscriber holds buffered and has not yet handed to the reader, as a single consistent reading.
CdcChangeType	A mutation applied by BigQuery change data capture.
CdcChangeTypeProvider<T>	Determines whether one record upserts or deletes its BigQuery primary key.
CdcOptions<T>	Options for appending BigQuery CDC mutations through the Storage Write API default stream.
CdcOptions.Builder<T>	Builder for CdcOptions.
CdcProtoRowFields	Creates the internal write-only fields that represent BigQuery CDC pseudocolumns.
CdcSequenceNumberProvider<T>	Extracts the BigQuery change sequence number for one record.
CdcTableOptions	Desired BigQuery table contract for CDC writes.
CdcTableOptions.Builder	Builder for CdcTableOptions.
CdcTableOptionsMapper	Maps Table API CDC table options onto their DataStream contract.
CdcTableOptionsProvider	Supplies the desired CDC table contract for each destination.
CdcTableReconciliationPolicy	Policy for a BigQuery CDC destination table that already exists.
CellValueCodec	Turns a RowData field into the bytes of a Bigtable cell, and back.
CellValueCodec.FieldDecoder	Reads the bytes of a cell as one field of a row.
CellValueCodec.FieldEncoder	Reads one field of a row as the bytes of a cell.
CellWeights	How many cells a mutation costs, counted the way Spanner counts a mutation.
ChangeStreamChangelogMode	The physical changelog representation emitted by a Bigtable Change Streams table source.
ChangeStreamChangelogMode	The relational changelog emitted from Spanner data-change records.
ChangeStreamCoordinatorClient	Coordinator-side Bigtable operations, separated so partition protocol tests need no service.
ChangeStreamCoordinatorClientFactory	Mints the ChangeStreamCoordinatorClient one enumerator coordinates through.
ChangeStreamMutationDispatcher	Dispatches a change-stream mutation entry or aggregate value to the connector code that handles it.
ChangeStreamMutationDispatcher.EntryVisitor<R,A>	Handles every mutation entry type the connector models.
ChangeStreamMutationDispatcher.ValueVisitor<R,A>	Handles every aggregate value type the connector models.
ChangeStreamOpener	Serializable seam that opens asynchronous ReadChangeStream RPCs.
ChangeStreamPartitions	The shape every Bigtable Change Streams partition has, and the conversion to the shape the SDK models require.
ChangeStreamPartitionSplit	One Bigtable Change Streams partition and the exact position from which it resumes.
ChangeStreamPartitionSplit	One Spanner Change Streams partition and its checkpointed coordinator lifecycle.
ChangeStreamPartitionSplitSerializer	Connector-owned checkpoint format for ChangeStreamPartitionSplit.
ChangeStreamPartitionSplitSerializer	Connector-owned checkpoint format for a Spanner Change Streams partition split.
ChangeStreamPartitionSplitState	Mutable task-thread state for one change-stream partition.
ChangeStreamPartitionSplitState	Mutable task-thread progress for one Spanner Change Streams partition.
ChangeStreamRestoreResolver	Resolves a reader-restored split against current retention.
ChangeStreamStartMode	A table option's Bigtable Change Streams start-position mode.
ChangeStreamStartMode	A Table API spelling for one shared Change Streams start position.
ChangeStreamStartPositionMapper	Maps one mode/timestamp option pair onto the shared Change Streams start-position API.
ChangeStreamStartPositionMapper	Maps Table API startup options to the shared change-stream start position.
ChildPartitionsEvent	One child-partitions record discovered while a reader is consuming a parent partition.
ChildPartitionsEvent.ChildPartition	One child token and the normalized coordinator identities of every parent.
Closers	Releasing several resources at once, so that one refusing to close never strands the rest.
CloudTasksConnectorOptions	The WITH options of the cloud-tasks table connector.
CloudTasksCreateTaskSink<T>	At-least-once sink creating one Cloud Tasks task per record through the CreateTask RPC, with fixed or per-record queue destinations.
CloudTasksDynamicSink	Insert-only table sink creating target tasks in one fixed queue.
CloudTasksDynamicTableFactory	Factory for the sink-only cloud-tasks table connector.
CloudTasksEmulatorContainers	The Cloud Tasks emulator image shared by every harness that starts the emulator, so they cannot drift apart.
CloudTasksMetricNames	Every metric name this connector registers itself, in one place so that this file is the connector's inventory: what it reports can be read here without opening the writer.
CloudTasksSerializationSchema<T>	Serializes sink records into Cloud Tasks tasks.
CloudTasksSink	Entry point for building a Cloud Tasks sink.
CloudTasksSinkBuilder<T>	Builder for Cloud Tasks sinks, obtained from CloudTasksSink.builder().
CloudTasksSinkConfig<T>	Immutable sink configuration assembled by CloudTasksSinkBuilder.
CloudTasksTargetType	The request target represented by a cloud-tasks table.
CloudTasksTestClients	A stock CloudTasksClient over one plaintext channel to the emulator, with no credentials, for queue administration and task inspection.
CloudTasksWriter<T>	At-least-once writer creating one Cloud Tasks task per record.
CloudTasksWriterOptions	Tuning options for the sink's writer: the in-flight cap, the transport channel pool and the two retry budgets.
CloudTasksWriterOptions.Builder	Builder for CloudTasksWriterOptions.
CollectingReaderOutput<T>	ReaderOutput for tests that drive SourceReaderBase.pollNext(...), delegating to one shared CollectingSourceOutput whatever split a record came from.
CollectingSourceOutput<T>	SourceOutput recording emitted records and their timestamps — what a RecordEmitter is handed, and what a test driving one asserts against.
ConstraintViolationPolicy	What the sink does with a mutation Spanner refuses for violating a constraint.
CopyJobSpec	Everything one BigQuery copy job needs, decoupled from the client for testability.
CreateDisposition	Whether the sink may create destination tables that do not exist.
CreateDisposition	Whether the sink may create the destination table when it does not exist.
CreateDisposition	Whether the sink may create destination topics that do not exist.
CrossVersionSink<InputT>	The cross-version seam every sink in this module implements instead of Sink directly.
CrossVersionSink<InputT>	The cross-version seam every sink in this module implements instead of Sink directly.
CrossVersionSink<InputT>	The cross-version seam every sink in this module implements instead of Sink directly.
CrossVersionSink<InputT>	The cross-version seam every sink in this module implements instead of Sink directly.
CrossVersionSink<InputT>	The cross-version seam every sink in this module implements instead of Sink directly.
DatabaseDestination	A fully-qualified Spanner database reference: project, instance and database.
DataChangeRecord	One data-change record returned by a Spanner Change Streams read function.
DataChangeRecord.Builder	Builder for DataChangeRecord.
DataChangeRecord.ColumnType	Per-record description of one watched column.
DataChangeRecordSerializer	Serializes DataChangeRecord without reflective access to JDK implementation fields.
DataChangeRecordSerializer.Snapshot	Snapshot for the connector-owned field format.
DataChangeRecordTypeInfoFactory	Supplies the connector-owned serializer for DataChangeRecord.
DataClientChangeStreamOpener	Opens change streams through a lazily created Bigtable data client.
DataClientRowKeySampler	Samples row keys through a google-cloud-bigtable BigtableDataClient.
DataClientRowStreamOpener	Opens reads through a google-cloud-bigtable BigtableDataClient.
DeadLetterQueue	Destination for elements that terminally failed to be written by a sink, used through FailureHandler.sendToDeadLetterQueue(DeadLetterQueue).
DebeziumMySqlCdcSequenceNumberEncoder	Transcodes Debezium MySQL GTID coordinates into BigQuery CDC sequence sections.
DebeziumMySqlCdcSequenceNumberProvider	Derives BigQuery CDC sequence numbers from Debezium MySQL source properties.
DebeziumPostgreSqlCdcSequenceNumberEncoder	Transcodes Debezium PostgreSQL sequence metadata into BigQuery CDC hexadecimal sections.
DebeziumPostgreSqlCdcSequenceNumberProvider	Derives BigQuery CDC sequence numbers from Debezium PostgreSQL source properties.
DebeziumSpannerCdcSequenceNumberProvider	Derives BigQuery CDC sequence numbers from Debezium Spanner source properties.
DefaultChangeStreamCoordinatorClient	Native java-bigtable implementation of the coordinator operations.
DefaultChangeStreamCoordinatorClientFactory	Mints DefaultChangeStreamCoordinatorClients.
DefaultChangeStreamRestoreResolver	Retention-aware reader restore resolution backed by Bigtable table metadata.
DefaultFailureHandlerContext	The FailureHandlerContext the sinks build from their WriterInitContext.
DefaultMutationBatcherFactory	Creates MutationBatchers backed by google-cloud-bigtable BigtableDataClients, connected the way BigtableDataClients connects every data client of this connector — that class owns the credential and emulator modes.
DefaultPartitionPlannerFactory	Mints BatchClientPartitionPlanners.
DefaultPublisherFactory	PublisherFactory building google-cloud-pubsub Publisher instances configured from PubSubPublisherOptions; every knob left unset keeps the SDK default (options with no batching or retry overrides leave the publisher builder untouched, so the default configuration is byte-identical to the SDK's).
DefaultReadSessionCreatorFactory	Mints ReadClientSessionCreators.
DefaultRowKeySamplerFactory	Mints DataClientRowKeySamplers.
DefaultSpannerChangeStreamCoordinatorClientFactory	Opens the Spanner service handle used for change-stream metadata discovery.
DefaultSpannerChangeStreamQueryClientFactory	Opens the Spanner client and bounded callback executor owned by one reader subtask.
DefaultSpannerDatabaseAccessFactory	Opens a real Spanner service handle and wraps it in a SpannerServiceAdapter.
DefaultStreamOptions	Options specific to WriteMethod.STORAGE_API_AT_LEAST_ONCE: how large append requests may grow, how the connector-driven re-append budget backs off, how the SDK retries retriable append failures in-stream, how the SDK's connection pool (multiplexing) is sized, and the writer's housekeeping (destinationIdleTimeout, flushInterval).
DefaultStreamOptions.Builder	Builder for DefaultStreamOptions.
DefaultStreamOptionsMapper	Maps the sink.default-stream.* options onto DefaultStreamOptions.
DefaultSubscriberFactory	SubscriberFactory building google-cloud-pubsub Subscriber instances configured from PubSubSubscriberOptions; every knob left unset keeps the SDK default, so the default configuration differs from the SDK's only in the two settings the source owns.
DefaultTaskCreatorFactory	Creates a TaskCreator backed by a google-cloud-tasks CloudTasksClient, connecting either to production Cloud Tasks with application-default or configured service-account credentials, or to an emulator over a plaintext channel with no credentials.
DeserializationFailurePolicy	What the source does with a message its deserialization schema cannot convert.
DestinationCommitExecutor	Runs independent destination actions with a fixed, committer-lifetime concurrency bound.
DestinationCommitExecutor.Worker	One worker's thread-confined BigQuery collaborators.
DestinationCommitExecutor.WorkerFactory	Builds one worker context, lazily on the thread that owns it.
DestinationMetrics	Optional per-destination send counters, as destination.NAME.recordsSend and destination.NAME.sendErrors on the writer's metric group, where NAME is the destination as the connector's docs page spells it.
DestinationMetrics.Counters	One destination's counters; a no-op instance when per-destination metrics are off.
DestinationResolution	The result of resolving a BigQuery destination for one record.
DestinationResolutionDispatcher	Dispatches destination-resolution results to the writer that owns the record.
DestinationResolutionDispatcher.Visitor<T>	Handles every destination-resolution result supported by the connector.
DestinationResolver<T>	Resolves the destination table for each record, enabling one sink instance to write to many tables (dynamic destinations).
DestinationResolver<T>	Resolves the destination table for each record, enabling one sink instance to write to many tables (dynamic destinations).
DestinationResolver<T>	Resolves the destination queue for each record, enabling one sink instance to write to many queues (dynamic destinations).
DestinationResolver<T>	Resolves the destination topic for each record, enabling one sink instance to publish to many topics (dynamic destinations).
Drains	Deadline-bounded draining of a running job's collect iterator.
EmulatorChannels	Transport channel providers pointing a gRPC client at an emulator.
EmulatorEndpoint	The host:port of a Google Cloud emulator, parsed and validated on the client rather than on a TaskManager after the job has been submitted (issue #235).
EnumeratorCounters	The three counters a PullAssignmentSplitEnumerator reports, registered by the connector under its own names.
ErrorClassCounters	Counts a sink's failures by the status code that caused them, as errorClass.CODE.errors on the writer's metric group.
FailedElement	An element that terminally failed to be written by one of this project's sinks — the read-only contract every connector's concrete failure type implements, and the view a cross-connector DeadLetterQueue sees.
FailedMessage	A single message that terminally failed to be published to Pub/Sub, as passed to a FailureHandler<FailedMessage>.
FailedMutation	A single row mutation that terminally failed to be written to Bigtable, as passed to a FailureHandler<FailedMutation>.
FailedMutation	A single mutation that terminally failed to be applied to Spanner, as passed to a FailureHandler<FailedMutation>.
FailedRow	A single row that terminally failed to be written to BigQuery, as passed to a FailureHandler<BigQueryFailure>.
FailedTask	A single task that terminally failed to be created in Cloud Tasks, as passed to a FailureHandler<FailedTask>.
FailureHandler<F extends FailedElement>	Pluggable policy for elements that terminally fail to be written by a sink.
FailureHandlerContext	What a FailureHandler or DeadLetterQueue learns about its surroundings when it is opened: enough to stamp per-subtask output and to register its own metrics, and nothing more.
FakeMailboxExecutor	A queue-backed MailboxExecutor for tests: FakeMailboxExecutor.execute(org.apache.flink.api.common.operators.MailboxExecutor.MailOptions, org.apache.flink.util.function.ThrowingRunnable<? extends java.lang.Exception>, java.lang.String, java.lang.Object...) enqueues mails, FakeMailboxExecutor.yield() runs the next mail (blocking until one arrives, like the real mailbox), and FakeMailboxExecutor.drain() runs every mail already enqueued.
FakeSourceReaderContext	In-memory SourceReaderContext for the tests of a pull-assignment source reader.
FakeSplitEnumeratorContext<SplitT extends org.apache.flink.api.connector.source.SourceSplit>	In-memory SplitEnumeratorContext for the tests of a pull-assignment enumerator — one whose readers ask for work through handleSplitRequest.
FileLoadsCheckpointStamper	The streaming pre-commit stage of the FILE_LOADS topology: stamps each committable with the checkpoint id carried by its CommittableMessage, which the Committer SPI cannot observe otherwise — the stamp selects the streaming behavior of the load-job orchestrator and makes BigQuery job ids attributable to their checkpoint.
FileLoadsCommittable	One finalized staging file: the Flink job id of the run that staged it, its destination table, its Cloud Storage URI, size counters used for load-job partitioning, and — in streaming execution — the checkpoint that triggered it.
FileLoadsCommittableSerializer	Serializer for FileLoadsCommittable.
FileLoadsCommitter	The real FILE_LOADS commit: turns one committable batch — a whole batch run, or one checkpoint of a streaming run — into BigQuery load jobs through a LoadJobOrchestrator.
FileLoadsCommitterMetrics	Thread-safe metrics for the bounded FILE_LOADS destination executor.
FileLoadsOptions	Options specific to WriteMethod.FILE_LOADS: where staging files go on Cloud Storage, how loaded rows land in tables that already hold data, where oversized loads stage their temporary tables, how checkpoint-triggered loads are paced in streaming execution, and the two schedules the committer backs off on.
FileLoadsOptions.Builder	Builder for FileLoadsOptions.
FileLoadsOptionsMapper	Maps the sink.file-loads.* options onto FileLoadsOptions.
FileLoadsWriter<T>	The FILE_LOADS SinkWriter: encodes records in the configured staging format and streams them to per-destination staging files on Cloud Storage, emitting one FileLoadsCommittable per finalized file from FileLoadsWriter.prepareCommit() — once at end of input in batch execution, once per checkpoint in streaming execution.
FixedDestinationResolver	A DestinationResolver returning one fixed destination for every record.
FixedDestinationResolver	A DestinationResolver returning one fixed destination for every record, which is what BigtableSinkBuilder.table(...) builds.
FixedDestinationResolver	A DestinationResolver returning one fixed destination for every record.
FixedDestinationResolver	A DestinationResolver returning one fixed destination for every record.
FormUrlEncodedFormatFactory	Table format factory for UTF-8 application/x-www-form-urlencoded bodies.
GcRule	A garbage-collection rule for a column family the sink creates, mirroring the four rule shapes Bigtable's admin API takes: a version cap, an age cap, and their union and intersection.
GcRule.Kind	The rule shapes Bigtable's admin API takes.
GcsStagingStorage	StagingStorage over the Cloud Storage client with configured credentials or ADC.
HttpContentTypeEncodingFormat	An encoding format that owns the HTTP Content-Type for body-carrying requests.
HttpTargetBuilder	The first stage of CloudTasksSerializationSchema.httpTarget(String): it carries the target URL and waits for the body schema.
HttpTargetSerializationSchema<T>	A CloudTasksSerializationSchema producing HTTP-target tasks: a URL, an HTTP method, an optional authorization token, optional headers, and a body serialized by a wrapped Flink SerializationSchema.
HttpTargetSerializationSchema.HeadersExtractor<T>	Extracts HTTP headers from a record.
HttpTargetSerializationSchema.UrlExtractor<T>	Extracts the target URL from a record.
HttpTargetSpec	Validated fixed HTTP request values used by the table serializer.
InsertOnlyInputMode	What the Bigtable table sink tells the planner when the requested changelog is insert-only.
JsonDocumentOptions	Options controlling how JSON records are converted to BigQuery rows.
JsonDocumentOptions.Builder	Builder for JsonDocumentOptions.
JsonDocumentSerializationSchema	A BigQueryProtoSerializationSchema for records that are JSON documents, as text.
LazyBigtableDataClient	A BigtableDataClient built on first use and closed once, held by a seam implementation that travels in the job graph.
LazyDerivedState<S>	Holds state its owner derives from its own serializable fields, once, and again on a task manager.
LoadJobOrchestrator	Runs the staged files of one run — a whole batch job, or one checkpoint of a streaming job — into their destination tables: submits every load, copy and terminal query through a LoadJobRunner, then deletes the temporary tables and the staged objects.
LoadJobRunner	Executes BigQuery load, copy and terminal query jobs for the FILE_LOADS orchestration.
LoadJobSpec	Everything one BigQuery load job needs, decoupled from the client for testability.
LogCapture	Captures what a class logs, so a test can assert the line rather than only its side effects.
LogCapture.Event	One collected log event, flattened out of log4j2's own type.
LogCapture.Level	The levels a capture can be taken at, so no log4j2 type reaches this class's signature.
LoopbackPortPublisher	Publishes every container's ports on the loopback address the Docker host resolves to, rather than on the wildcard address, so a host-port collision with an unrelated local process cannot form (ADR-0132).
MeasuredRow	A materialised Bigtable row and the stable byte estimate measured while it was decoded.
MeasuringRowAdapter	Materialises SDK rows while measuring their decoded wire content without traversing them twice.
MetricValues	Shared boundary handling for connector metric values.
MissingCheckpointDetector	Fails a reader that holds unacknowledged messages but has never been asked for a checkpoint.
MissingPartition	Checkpointed timer for a service partition absent from the coordinator ledger.
Mod	JSON values describing the changes to one watched table row.
ModType	The operation represented by one Spanner change-stream modification.
MutationBatcher	Accepts row mutations for one table and reports each one's outcome separately.
MutationBatcherFactory	Creates one MutationBatcher per table the writer resolves, and owns whatever those batchers share.
OffsetRowAppender	Appends row batches to one buffered write stream at explicit offsets.
OptionChecks	The checks every connector's option builders repeat, in one place.
OptionDescriptionAssertions	Assertions shared by the Table API option-set tests.
OptionSetters	Applies Table API option values to DataStream builder setters, renaming a rejected value's failure to the option key the SQL caller actually wrote (issue #1030, ADR-0133).
OptionSetters	Applies Table API option values to DataStream builder setters, renaming a rejected value's failure to the option key the SQL caller actually wrote (issue #1030, ADR-0133).
OptionSetters	Applies Table API option values to DataStream builder setters, renaming a rejected value's failure to the option key the SQL caller actually wrote (issue #1030, ADR-0133).
OptionSetters	Applies Table API option values to DataStream builder setters, renaming a rejected value's failure to the option key the SQL caller actually wrote (issue #1030, ADR-0133).
OptionSetters	Applies Table API option values to DataStream builder setters, renaming a rejected value's failure to the option key the SQL caller actually wrote (issue #1030, ADR-0133).
OrderingMode	Whether the source preserves Pub/Sub ordering-key delivery order.
ParquetCompression	How StagingFormat.PARQUET staging files are compressed.
PartitionFinishedEvent	Reports successful end-of-query after all child-partitions records were forwarded.
PartitionLifecycleState	Lifecycle of one Spanner Change Streams partition in the checkpointed coordinator ledger.
PartitionPlan	What one planning call answered with: a snapshot, and the partitions of the read at it.
PartitionPlanner	Opens a batch read and asks the service to plan it into partitions.
PartitionPlannerFactory	Mints the PartitionPlanner one enumerator plans through.
PartitionProgressEvent	Reader heartbeat progress used to keep the coordinator's recovery watermark current.
PartitionProgressEvent	Reader progress used to keep the coordinator's assigned-partition ledger current.
PartitionTransitionEvent	Reports that a partition closed and names each successor range and its continuation token.
PartitionTransitionEvent.Successor	One target range from CloseStream paired with the token that arrived from this parent.
PausedSplitBufferLimits	How much a paused split may buffer before the reader stops its subscriber.
PendingMerge	Successor partition parked until its parent tokens cover the whole target range.
PlannedSplit	A split as the planner produced it, with the size the samples suggest it holds.
ProtoDescriptorAugmenter	Adds fields to a protobuf row descriptor without changing its surrounding file structure.
ProtoMessageSerializationSchema<T extends com.google.protobuf.Message>	A BigQueryProtoSerializationSchema for records that already are protobuf messages.
ProtoRowAugmentationField<T>	One validated field consumed by the generic protobuf row-augmentation engine.
ProtoRowAugmentationField.ValueProvider<T>	Serializable provider whose validation may report a row-level IOException.
ProtoRowAugmentationField.WriteOnlyField	Write-only fields accepted by BigQuery's documented Storage Write API contract.
ProtoRowAugmentingSerializer<T>	Adds ordered physical or write-only fields to delegate protobuf rows.
ProtoRowConverter	Rewrites protobuf messages into DynamicMessages conforming to a BigQuery-storage compatible target descriptor (as produced by BQTableSchemaToProtoDescriptor from the schema derived by ProtoToTableSchemaConverter).
ProtoSchemaOptions	Options controlling how protobuf descriptors are mapped to BigQuery schemas.
ProtoSchemaOptions.Builder	Builder for ProtoSchemaOptions.
ProtoToAvroConverter	Converts serialized proto rows (the BigQueryProtoSerializationSchema wire form, whose descriptors follow the BQTableSchemaToProtoDescriptor conventions) into Avro GenericRecords conforming to the schema produced by TableSchemaToAvroConverter.
ProtoToTableSchemaConverter	Derives a BigQuery TableSchema from a protobuf Descriptors.Descriptor.
PublisherFactory	Creates TopicPublisher instances for the writer's per-topic publisher map.
PublisherOptionsMapper	Builds PubSubPublisherOptions from the table options.
PubSubAckTracker	AckTracker keeping the acknowledgement handles in memory until their checkpoint completes.
PubSubConnectorOptions	The WITH options of the pubsub table connector.
PubSubCredentials	Loads the credentials shared by the Pub/Sub source and sink client families.
PubSubDeadLetterQueue	A DeadLetterQueue publishing every terminally failed element to a Pub/Sub topic, used through FailureHandler.sendToDeadLetterQueue(DeadLetterQueue).
PubSubDeadLetterQueue.Builder	Builder for PubSubDeadLetterQueue.
PubSubDeserializationSchema<T>	Deserializes Pub/Sub messages into source records.
PubSubDynamicSink	A table sink publishing rows to one Pub/Sub topic.
PubSubDynamicSource	A table source consuming rows from one or more Pub/Sub subscriptions.
PubSubDynamicTableFactory	The pubsub table connector factory.
PubSubEmulatorContainers	The Pub/Sub emulator image shared by every harness that starts the emulator, so they cannot drift apart.
PubSubEnumeratorState	Checkpointed state of the split enumerator: the subscriptions it resolved.
PubSubEnumeratorStateSerializer	Serializer for PubSubEnumeratorState.
PubSubMetricNames	Every metric name this connector registers itself, in one place so that this file is the connector's inventory: what it reports can be read here without opening a writer, a reader or the enumerator.
PubSubPublisherOptions	Tuning options for the sink's Pub/Sub publishers and its writer: SDK batching and publish-retry settings, message ordering, the writer's in-flight caps, the backoff budget of the topic auto-creation recovery, and the writer's shutdown budget.
PubSubPublisherOptions.Builder	Builder for PubSubPublisherOptions.
PubSubPublisherSink<T>	At-least-once sink publishing through google-cloud-pubsub Publisher instances with dynamic per-record topic destinations.
PubSubRecordEmitter<T>	Deserializes received messages and emits them, using the Pub/Sub publish time as the event timestamp.
PubSubSerializationSchema<T>	Serializes sink records into Pub/Sub messages.
PubSubSerializationSchema.AttributesExtractor<T>	Extracts message attributes from a record.
PubSubSerializationSchema.OrderingKeyExtractor<T>	Extracts the ordering key from a record.
PubSubShutdownResidue	What this connector's bounded teardowns leave behind, counted for the lifetime of the class loader rather than of a task.
PubSubSink	Entry point for building a Pub/Sub sink.
PubSubSinkBuilder<T>	Builder for Pub/Sub sinks, obtained from PubSubSink.builder().
PubSubSinkConfig<T>	Immutable sink configuration assembled by PubSubSinkBuilder.
PubSubSource	Entry point for building Pub/Sub sources.
PubSubSourceBuilder<T>	Builder for Pub/Sub sources, obtained from PubSubSource.builder().
PubSubSourceConfig<T>	Immutable configuration of a Pub/Sub source, assembled by PubSubSourceBuilder and shipped in the job graph.
PubSubSourceReader<T>	Reader subtask consuming its assigned subscription splits.
PubSubSourceReaderMetrics	The reader's Pub/Sub-specific metrics.
PubSubSplitEnumerator	Verifies the subscriptions, then assigns subscription splits to reader subtasks.
PubSubSplitReader	Multiplexes the streaming-pull subscribers of one reader subtask's splits.
PubSubSplitReaders	Fetch-loop helpers for driving a Pub/Sub SplitReader directly in tests, typed against the flink-connector-base interface so the connector's reader class never crosses the module boundary.
PubSubStartPosition	Where the source starts consuming a subscription.
PubSubStartPosition.Mode	Which starting point a PubSubStartPosition names.
PubSubStreamingPullSource<T>	At-least-once source consuming Pub/Sub subscriptions through google-cloud-pubsub Subscriber streaming pull.
PubSubSubscriberOptions	Tuning options for the source's Pub/Sub subscribers and its reader: SDK flow control, the streaming-pull connection count and the acknowledgement-deadline extension settings, plus the source's own drain size, subscriber shutdown budget and first-checkpoint watchdog.
PubSubSubscriberOptions.Builder	Builder for PubSubSubscriberOptions.
PubSubSubscriptionAdmin	Default SubscriptionAdmin backed by the Pub/Sub SubscriptionAdminClient.
PubSubTestClients	The Pub/Sub admin, publish and pull machinery every integration-test harness needs, parameterised over the transport: a plaintext channel with no credentials against the emulator, or application-default credentials against the real service.
PubSubTopicAdmin	Default TopicAdmin backed by the Pub/Sub TopicAdminClient.
PubSubWriter<T>	At-least-once writer publishing records to dynamic per-record Pub/Sub topic destinations.
PullAssignmentSplitEnumerator<SplitT extends org.apache.flink.api.connector.source.SourceSplit,StateT,PlanT>	A bounded source's split enumerator that plans once, asynchronously, and then hands the plan out one split per request.
PullSubscriber	Bridges Pub/Sub's push-style streaming pull to the pull-style SplitReader contract: the client library delivers messages on its own threads into an in-memory buffer, and the fetcher thread drains that buffer.
QueryJobIdentity	The deterministic identity under which a query job may be reused across a re-plan.
QueryJobSpec	Everything one terminal BigQuery query job needs, decoupled from the client for testability.
QueryResult	What running the query produced: the table the result landed in, and whether it came from a previous attempt's job rather than a fresh submission.
QueryRunner	Runs the source's query and says which table its result landed in.
QuerySpec	The query job a QueryRunner is asked to run.
QueueDestination	A fully-qualified Cloud Tasks queue reference: project, location and queue.
ReadClientRowStreamOpener	Opens ReadRows calls through a BigQueryReadClient.
ReadClientSessionCreator	Creates read sessions through a BigQueryReadClient.
ReaderCapacityEvent	Absolute number of additional partition splits one reader can accept.
ReaderInitializationContext	Adapts a SourceReaderContext to the context a DeserializationSchema expects when a source opens it.
ReadSessionCreator	Creates the source's read session.
ReadSessionCreatorFactory	Mints the ReadSessionCreator one enumerator plans through.
ReadStreamSplit	One Storage Read API ReadStream, plus how far into it the source has already consumed.
ReadStreamSplitSerializer	Serializer for ReadStreamSplit.
ReadStreamSplitState	The mutable reading progress of one ReadStreamSplit.
ResidueCounter	A read-only Counter view of one PubSubShutdownResidue adder, so a residue registers as the counter it is rather than as a gauge over a monotonic total.
ResourceNames	The check a configured value earns by being a component of a resource path this project composes.
RetriableTableAdminException	A TableAdmin failure that repeating the same call can fix — a rate limit, a quota that refills, a server-side error.
Retries	Support for the connectors' hand-written retry loops.
RetryingTableAdmin	A TableAdmin that repeats a creation the service answered with a RetriableTableAdminException, within a fixed budget.
RetrySchedule	An immutable retry schedule: exponential backoff from an initial delay up to a cap, a bounded number of attempts, and optional proportional jitter (to de-synchronize parallel subtasks retrying against the same destination).
RowAppender	Appends batches of serialized rows to one destination's default write stream.
RowAppenderFactory	Creates RowAppenders for destinations.
RowDataSchemaOptions	How RowTypeToTableSchemaConverter derives a BigQuery schema from a SQL table's columns — the RowData counterpart of AvroSchemaOptions, carrying the same three knobs under the same names.
RowDataSchemaOptions.Builder	Builder for RowDataSchemaOptions.
RowDataSerializationSchema	Serializes table-runtime rows into mutations for one configured table.
RowDescriptors	Derives the protobuf row descriptor a BigQuery table schema is written through.
RowKeyEncoding	How a Bigtable table option represents a row-key bound.
RowKeySample	One row key the service offered as a section boundary, with the approximate number of bytes stored before it.
RowKeySampler	Asks the service where a table's sections begin.
RowKeySamplerFactory	Mints the RowKeySampler one enumerator plans against.
RowRanges	The module's row-key range algebra: emptiness, containment, cutting, coalescing, intersection, truncation and the unsigned key comparison they all rest on, each defined once here.
RowRangeSplit	One contiguous row-key range still to be read.
RowRangeSplitPlanner	Cuts the configured row-key ranges at the boundaries the service sampled.
RowRangeSplitSerializer	Serializer for RowRangeSplit.
RowRangeSplitState	How far through one RowRangeSplit the source has emitted.
RowStream	One open ReadRows call: the response blocks of one stream, from one offset onwards.
RowStream	One open ReadRows call, consumed a row at a time.
RowStreamOpener	Opens ReadRows calls on a read session's streams.
RowStreamOpener	Opens a ReadRows call over one row-key range.
ScanMode	Which Bigtable read surface a table source uses.
ScanMode	The Spanner read path selected by a table DDL.
SchemaUnifier	Computes the union of a destination table's live schema and the serializer's desired schema — the schema the sink proposes when connector-driven schema updates are enabled.
SchemaUnifier.SchemaUnionException	A checked rejection of a schema union: the desired schema requires a change the rules (or the configured options) do not permit.
SchemaUnifier.UnionResult	The result of a union: the unified schema and whether it differs from the existing one.
SchemaUpdateOptions	Options gating connector-driven destination table schema updates.
SchemaUpdateOptions.Builder	Builder for SchemaUpdateOptions.
SelectedCellTableSchema	The physical primary key and value-format payload of a selected-cell table.
ServiceAccountKeyFiles	Creates synthetic service-account keys for credential wiring tests: structurally valid enough for the Google auth libraries to parse — a real RSA key in a real PEM envelope — while naming an example.invalid account no service would ever accept, so a test that leaks one at a real endpoint fails loudly rather than authenticating.
ShadedJar	Locates the uber-jar a flink-sql-connector-gcp-* module builds, for the tests that inspect or run against it.
SpannerBatchReadEnumeratorState	What the split enumerator checkpoints: whether the read has been planned, and the splits nobody is holding yet.
SpannerBatchReadEnumeratorStateSerializer	Serializer for SpannerBatchReadEnumeratorState.
SpannerBatchReadSource<T>	The bounded batch source over Spanner's partitioned reads.
SpannerBatchReadSplitEnumerator	Opens one batch read, asks Spanner to plan it into partitions, and hands the partitions out one at a time.
SpannerCdcSequenceNumber	Builds BigQuery CDC sequence numbers from typed Spanner change-stream coordinates.
SpannerCdcSequenceNumberEncoder	Transcodes Spanner change-stream coordinates into BigQuery CDC hexadecimal sections.
SpannerChangeStreamCoordinatorClient	Metadata operations the Spanner Change Streams coordinator needs during initialization.
SpannerChangeStreamCoordinatorClientFactory	Serializable job-graph seam that opens the coordinator's runtime metadata client.
SpannerChangeStreamDeserializationSchema<T>	Turns one Spanner data-change record into zero or more user records.
SpannerChangeStreamDynamicSource	An unbounded Table API source for one table observed through a Spanner change stream.
SpannerChangeStreamEnumeratorState	Checkpointed Spanner Change Streams partition state.
SpannerChangeStreamEnumeratorStateSerializer	Connector-owned checkpoint format for the Spanner Change Streams partition ledger.
SpannerChangeStreamInitializationEvent	Releases readers after the coordinator has validated Change Stream metadata and restore age.
SpannerChangeStreamQueryClient	Opens asynchronous partition queries for one source subtask.
SpannerChangeStreamQueryClient.QueryHandle
SpannerChangeStreamQueryClient.SpannerChangeStreamQueryListener
SpannerChangeStreamQueryClientFactory	Serializable factory for the TaskManager-local Change Streams query client.
SpannerChangeStreamReader<T>	Reads several Spanner Change Streams partition queries concurrently in one source subtask.
SpannerChangeStreamRecordFilter	Applies connector-side table and column filters to decoded data-change records.
SpannerChangeStreamRecordFilter.Result	Result of applying table and column filters to one data-change record.
SpannerChangeStreamRecordFilter.Result.Disposition
SpannerChangeStreamSource<T>	FLIP-27 source for Cloud Spanner Change Streams.
SpannerChangeStreamSourceBuilder<T>	Builds a SpannerChangeStreamSource.
SpannerChangeStreamSourceConfig<T>	Immutable configuration assembled by SpannerChangeStreamSourceBuilder.
SpannerChangeStreamSplitEnumerator	Coordinates the checkpointed parent-child lifecycle of Spanner Change Streams partitions.
SpannerChangeStreamWatermarkEvent	Advances every reader subtask to the coordinator's unfinished-ledger watermark.
SpannerChangeStreamWatermarks	Calculates the non-early Flink watermark for the complete Spanner partition ledger.
SpannerClients	Builds the Spanner service handle both directions of this connector open.
SpannerConnectorOptions	The WITH options of the spanner table connector.
SpannerCredentials	Loads credentials shared by every direction of this connector: the sink writer, the bounded source's planner and readers, the Change Streams coordinator and query clients, and the table lookup path.
SpannerDatabaseAccess	The narrow view of a Spanner database the writer needs: read the schema once, then apply batches.
SpannerDatabaseAccess.GroupOutcomes	Receives the outcome of one mutation group of a batch write.
SpannerDatabaseAccessFactory	Opens a SpannerDatabaseAccess on the task manager.
SpannerDynamicSink	The spanner table sink, backed by the DataStream SpannerSink.
SpannerDynamicSink.Builder	Collects values for the immutable sink.
SpannerDynamicSource	A bounded table scan and primary-key point-lookup source for Spanner tables.
SpannerDynamicTableFactory	Creates the spanner table source and sink from a SQL DDL.
SpannerEmulatorContainers	The Spanner emulator image shared by every harness that starts the emulator, so they cannot drift apart.
SpannerLookupConfig	Lookup options owned by the Spanner table source.
SpannerMetricNames	Every metric name this connector registers, in one place.
SpannerMutationSerializationSchema<T>	Turns a stream record into the Spanner Mutation the sink writes.
SpannerMutationsSink<T>	At-least-once sink applying one mutation per record through batchWriteAtLeastOnce of google-cloud-spanner.
SpannerReadOperation	What the batch source reads: either a query, or a table with its columns and key set, optionally through an index.
SpannerReadOperationResolution	Internal bridge between a table-layer deferred read and the batch partition planner.
SpannerReadOperationResolver	Resolves a table-layer read after the batch transaction has selected its snapshot.
SpannerRecordEmitter<T>	Deserializes each row and hands its output records on.
SpannerRowDataAsyncLookupFunction	Asynchronous primary-key lookup producing the projected table row.
SpannerRowDataLookupFunction	Synchronous primary-key lookup producing the projected table row.
SpannerRpcPriority	The priority Spanner schedules this connector's requests at.
SpannerSink	Entry point for building a Spanner sink.
SpannerSinkBuilder<T>	Builder for the Spanner sink; created through SpannerSink.builder().
SpannerSinkConfig<T>	The immutable configuration SpannerSinkBuilder builds and the sink carries to the task managers.
SpannerSource	Reads rows from a Cloud Spanner database.
SpannerSourceBuilder<T>	Builds a SpannerSource.
SpannerSourceConfig<T>	Everything the batch source was built with, assembled by the builder and carried into the job graph.
SpannerSourceReader<T>	Reads the partitions this subtask is assigned, asking the enumerator for the next one each time it finishes one.
SpannerSourceReaderMetrics	The batch reader's own counters, beside the ones Flink registers for every source.
SpannerSplitReader	Reads the partitions this subtask was assigned, a bounded batch at a time.
SpannerStructDeserializationSchema<T>	Turns a Spanner row into zero or more output records.
SpannerTableName	A table name as rendered for Spanner APIs and compared with INFORMATION_SCHEMA.
SpannerTableName.AccessPathName	The name of one table-local access path, such as an index.
SpannerTableSchemaConverter	The physical DDL schema and its corresponding native Spanner types.
SpannerTableSchemaConverter.Column	One physical column.
SpannerTestClients	Stock Spanner clients pointed at an emulator endpoint.
SpannerWriter<T>	The Spanner sink's writer: buffers mutations, applies them with batchWriteAtLeastOnce, and decides per mutation what a refusal means.
SpannerWriterOptions	Tuning options for the sink's writer: how large a batch write request grows, how Spanner should schedule it, and the recovery budget the writer spends on transient failures.
SpannerWriterOptions.Builder	Builder for SpannerWriterOptions.
SplitAssignmentPlan	The split universe of a job and its subtask ownership, computed deterministically from the subscription list, the ordering mode and the source parallelism.
StagingFormat	The file format FILE_LOADS stages rows in before loading them, set by FileLoadsOptions.Builder#stagingFormat.
StagingStorage	The Cloud Storage staging area of the FILE_LOADS write method.
StartPosition	Where a change-stream source starts reading when no checkpointed state is restored.
StartPositionMapper	Builds a PubSubStartPosition from the table options.
StartPositionResolver	Resolves change-stream start positions against one startup instant and one retention window.
StartPositionResolver.RestoreExpiry	The retained-window evidence for one expired restored partition.
StartPositionResolver.RetentionLookup	Discovers how long a connector's change stream retains records.
StatusCodes	Extraction of gRPC status codes from the exceptions the Google Cloud clients surface.
StorageSchemaConverter	Converts a Storage API TableSchema (the schema form of the serializer SPI) into the REST client Schema needed to create tables.
StreamWriterRowAppenderFactory	Default RowAppenderFactory backed by Storage Write API StreamWriters on the destination's default write stream.
StructStream	One open read of a partition, consumed a row at a time.
StructStreamOpener	Rejoins a batch read's snapshot and opens one of its partitions.
StubWriterInitContext	The parts of WriterInitContext a sink reads when creating a writer; everything a sink has no reason to touch is unsupported, so a new dependency on the context shows up as a failing test rather than as a silent null.
SubscriberBufferLimitExceededEvent	Reports that one source reader could not admit a delivery within its subscriber-buffer bound.
SubscriberFactory	Creates the google-cloud-pubsub Subscriber backing one split.
SubscriberFactory.MessageConsumer	Receives a message together with the handle that settles it.
SubscriberOptionsMapper	Builds PubSubSubscriberOptions from the table options.
SubscriptionAdmin	Subscription administration used by the enumerator's startup check, abstracting the Pub/Sub admin client so the check can be unit-tested without one.
SubscriptionCreateOptions	Settings the source applies when it creates a subscription that does not exist.
SubscriptionCreateOptions.Builder	Builder for SubscriptionCreateOptions.
SubscriptionCreateOptionsMapper	Builds per-subscription SubscriptionCreateOptions from the table options.
SubscriptionDestination	A fully-qualified Pub/Sub subscription reference: project and subscription.
SubscriptionInfo	The settings of an existing subscription that the source's preflight reads.
SubscriptionInfo.Builder	Builder for SubscriptionInfo.
SubscriptionSplit	A unit of work for one reader subtask: a streaming-pull connection to one subscription.
SubscriptionSplitSerializer	Serializer for SubscriptionSplit.
SynchronousDeserializationCollector	Runs one source deserialization call with a direct, non-null collector.
SynchronousDeserializationCollector.Invocation<T,E extends Exception>	One deserialization call that emits through the supplied collector.
TableAdmin	Administers destination tables: creation for CreateDisposition.CREATE_IF_NEEDED and schema reads/updates for schema evolution.
TableAdmin	Table administration operations used by the sink, abstracting the Bigtable admin client so writer logic can be unit-tested without one.
TableAdmin.EnsureResult	What an TableAdmin.ensureTable(io.github.flink.gcp.connector.bigtable.TableDestination, io.github.flink.gcp.connector.bigtable.sink.TableCreateOptions) call actually did, so the caller can report creation and family-addition separately without this SPI knowing about metrics.
TableAdminException	A table-administration failure that retains whether the operation requested creation.
TableCreateOptions	Options applied when the sink creates a destination table under CreateDisposition.CREATE_IF_NEEDED: time partitioning and clustering.
TableCreateOptions	The settings for the table the sink creates under CreateDisposition.CREATE_IF_NEEDED: its column families and, per family, an optional garbage-collection rule.
TableCreateOptions.Builder	Builder for TableCreateOptions.
TableCreateOptions.Builder	Builder for TableCreateOptions.
TableCreateOptions.TimePartitioningType	Granularity of time-based partitioning.
TableCreateOptionsMapper	Maps the sink.table-create.* options onto TableCreateOptions.
TableCreateOptionsMapper	Builds TableCreateOptions from the table options and the DDL's column families.
TableCreateOptionsProvider	Supplies per-destination TableCreateOptions for tables created under CreateDisposition.CREATE_IF_NEEDED.
TableDestination	A fully-qualified BigQuery table reference: project, dataset and table.
TableDestination	A fully-qualified Bigtable table reference: project, instance and table.
TableSchemaSnapshot	A point-in-time read of a destination table's schema, as returned by TableAdmin.getSchema(io.github.flink.gcp.connector.bigquery.sink.TableDestination).
TableSchemaToAvroConverter	Converts a Storage API TableSchema (the schema form of the serializer SPI) into the Avro schema staged files are written with.
TargetSpec	Validated fixed target values used by the table sink.
TaskCreator	Creates Cloud Tasks tasks, one RPC per task.
TaskCreatorFactory	Creates the writer's TaskCreator.
TaskIdExtractor<T>	Extracts the deduplication key of a record, opting the sink into named tasks.
TestContexts	Shared test stubs for SinkWriter.Context.
TestNames	Random resource-name helpers for tests whose resources share a namespace — the gated real-GCP suites above all, where concurrent runs must not collide on resource names and a crashed run must leave behind names that identify it, but also an emulator harness giving each test a database of its own.
TestSinkCommitterMetricGroup	A SinkCommitterMetricGroup whose metrics can be read back by the names they registered under — TestSinkCommitterMetricGroup is to a committer what TestSinkWriterMetricGroup is to a writer, and for the same reason: UnregisteredMetricsGroup.createSinkCommitterMetricGroup() hands out a fresh SimpleCounter per call, so a counter the committer registered is unreachable afterwards.
TestSinkWriterMetricGroup	A SinkWriterMetricGroup whose metrics can be read back by the names they registered under, so a sink writer's metrics are asserted the way a reporter would see them.
TiCdcSequenceNumberEncoder	Transcodes a TiCDC commit TSO into a BigQuery CDC sequence section.
TiCdcSequenceNumberProvider	Derives BigQuery CDC sequence numbers from TiCDC's Debezium-protocol source properties.
TimeSource	The writer's view of time: reading the clock and waiting out a retry backoff.
TopicAdmin	Topic administration operations used by the sink, abstracting the Pub/Sub admin client so writer logic can be unit-tested without one.
TopicCreateOptions	Settings the sink applies when it creates a topic that does not exist.
TopicCreateOptions.Builder	Builder for TopicCreateOptions.
TopicCreateOptionsMapper	Builds TopicCreateOptions from the table options.
TopicDestination	A fully-qualified Pub/Sub topic reference: project and topic.
TopicPublisher	Publishes messages to one Pub/Sub topic.
TrailingBytes	What a fixed-width decoder does with a cell or row key longer than the declared type's layout.
UnroutableRecord	An explicit, record-specific destination-resolution failure.
UuidStringParser	Parses the table layer's string carrier as a native Spanner UUID value.
ValueCaptureType	The value-capture policy that was active when a data change was recorded.
WriteClientBufferedStreamService	Production BufferedStreamService over one BigQueryWriteClient.
WriteClientBufferedStreamServiceFactory	Default BufferedStreamServiceFactory creating WriteClientBufferedStreamServices.
WriteDisposition	How data lands in a destination table that already contains data.
WriteMethod	The mechanism used to write records to BigQuery.
WriterOptionsMapper	Builds BigtableWriterOptions from the table options.
WriterOptionsMapper	Maps Table API options onto the DataStream writer options.
WriterOptionsMapper	Maps table options onto SpannerWriterOptions.