DelayedKafkaAvroSourceFactory

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clazz: Class[ConsumerRecord[K, V]]

def clone(): AnyRef

def contextTransformation(context: ValidationContext, dependencies: List[NodeDependencyValue])(implicit nodeId: NodeId): NodeTransformationDefinition

def createDelayedKafkaSource[K, V](preparedTopics: List[PreparedKafkaTopic], kafkaConfig: KafkaConfig, deserializationSchema: KafkaDeserializationSchema[ConsumerRecord[K, V]], timestampAssigner: Option[TimestampWatermarkHandler[ConsumerRecord[K, V]]], formatter: RecordFormatter, flinkContextInitializer: FlinkContextInitializer[ConsumerRecord[K, V]], delay: Long): KafkaSource[ConsumerRecord[K, V]]

def createSource(params: Map[String, Any], dependencies: List[NodeDependencyValue], finalState: Option[State], preparedTopics: List[PreparedKafkaTopic], kafkaConfig: KafkaConfig, deserializationSchema: KafkaDeserializationSchema[ConsumerRecord[K, V]], timestampAssigner: Option[TimestampWatermarkHandler[ConsumerRecord[K, V]]], formatter: RecordFormatter, flinkContextInitializer: FlinkContextInitializer[ConsumerRecord[K, V]]): KafkaSource[ConsumerRecord[K, V]]

Basic implementation of new source creation.

def determineSchemaAndType(schemaDeterminer: AvroSchemaDeterminer, paramName: Option[String])(implicit nodeId: NodeId): Validated[ProcessCompilationError, (Option[RuntimeSchemaData], TypingResult)]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extractPreparedTopic(params: Map[String, Any]): PreparedKafkaTopic

def extractTimestampFromField(fieldName: String)(element: ConsumerRecord[K, V], kafkaEventTimestamp: Long): Long

def extractVersionOption(params: Map[String, Any]): SchemaVersionOption

val fallbackVersionOptionParam: Parameter

final def getClass(): Class[_]

def getTopicParam(implicit nodeId: NodeId): WithError[Parameter]

def getVersionParam(versions: List[Integer]): Parameter

def getVersionParam(preparedTopic: PreparedKafkaTopic)(implicit nodeId: NodeId): WithError[Parameter]

def hashCode(): Int

def implementation(params: Map[String, Any], dependencies: List[NodeDependencyValue], finalState: Option[State]): FlinkSource[ConsumerRecord[K, V]]

def initialParameters: List[Parameter]

final def isInstanceOf[T0]: Boolean

val kafkaConfig: KafkaConfig

final def ne(arg0: AnyRef): Boolean

def nextSteps(context: ValidationContext, dependencies: List[NodeDependencyValue])(implicit nodeId: NodeId): NodeTransformationDefinition

def nodeDependencies: List[NodeDependency]

final def notify(): Unit

final def notifyAll(): Unit

val nullTopicOption: FixedExpressionValue

def paramsDeterminedAfterSchema: List[Parameter]

def parseVersionOption(versionOptionName: String): SchemaVersionOption

def prepareKafkaConfig: KafkaConfig

def prepareKeySchemaDeterminer(preparedTopic: PreparedKafkaTopic): AvroSchemaDeterminer

def prepareSourceFinalErrors(context: ValidationContext, dependencies: List[NodeDependencyValue], parameters: List[(String, DefinedParameter)], errors: List[ProcessCompilationError])(implicit nodeId: NodeId): FinalResults

def prepareSourceFinalResults(preparedTopic: PreparedKafkaTopic, valueValidationResult: Validated[ProcessCompilationError, (Option[RuntimeSchemaData], TypingResult)], context: ValidationContext, dependencies: List[NodeDependencyValue], parameters: List[(String, DefinedParameter)], errors: List[ProcessCompilationError])(implicit nodeId: NodeId): FinalResults

def prepareTimestampAssigner[K, V](kafkaConfig: KafkaConfig, extract: (ConsumerRecord[K, V], Long) ⇒ Long): TimestampWatermarkHandler[ConsumerRecord[K, V]]

def prepareTopic(topic: String): PreparedKafkaTopic

def prepareValueSchemaDeterminer(preparedTopic: PreparedKafkaTopic, version: SchemaVersionOption): AvroSchemaDeterminer

val processObjectDependencies: ProcessObjectDependencies

def schemaParamStep(implicit nodeId: NodeId): NodeTransformationDefinition

lazy val schemaRegistryClient: SchemaRegistryClient

val schemaRegistryProvider: SchemaRegistryProvider

- provides a set of strategies for serialization and deserialization while event processing and/or testing.

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

val topicParamName: String

def topicParamStep(implicit nodeId: NodeId): NodeTransformationDefinition

def topicSelectionStrategy: TopicSelectionStrategy

def typedDependency[C](list: List[NodeDependencyValue])(implicit arg0: ClassTag[C]): C

final def validateTopic(topic: String): Validated[TopicExistenceValidationException, String]

final def validateTopics(topics: List[String]): Validated[TopicExistenceValidationException, List[String]]

lazy val validator: CachedTopicsExistenceValidator

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit