KafkaAvroSinkFactory

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

def createSink(preparedTopic: PreparedKafkaTopic, version: SchemaVersionOption, key: LazyParameter[AnyRef], value: LazyParameter[AnyRef], kafkaConfig: KafkaConfig, serializationSchemaFactory: KafkaAvroSerializationSchemaFactory, schemaDeterminer: AvroSchemaDeterminer, validationMode: ValidationMode)(implicit processMetaData: MetaData, nodeId: NodeId): FlinkSink

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

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]): FlinkSink

def initialParameters: List[Parameter]

final def isInstanceOf[T0]: Boolean

val kafkaConfig: KafkaConfig

final def ne(arg0: AnyRef): Boolean

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 prepareTopic(topic: String): PreparedKafkaTopic

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

val processObjectDependencies: ProcessObjectDependencies

def requiresOutput: Boolean

def schemaParamStep(implicit nodeId: NodeId): NodeTransformationDefinition

lazy val schemaRegistryClient: SchemaRegistryClient

val schemaRegistryProvider: SchemaRegistryProvider

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]]

def validateValueType(valueType: TypingResult, schema: Schema, validationMode: ValidationMode)(implicit nodeId: NodeId): Validated[CustomNodeError, Unit]

Currently we check only required fields, because our typing mechanism doesn't support optionally fields

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