connector

type AvroToJSONTransformer struct {
	// contains filtered or unexported fields
}

type BatchSink struct {
	TargetURL    string
	Send         chan Message
	Client       *retryablehttp.Client
	BufferSize   int
	FlushTimeout time.Duration
	FormatToBIRs FormatToBIRs // TODO: Change to be more generic ? (sending []byte or interface{})
	DryRun       bool
}

type BulkIngestRequest struct {
	UUID         string     `json:"uuid"`
	DocumentType string     `json:"documentType"`
	MergeConfig  []Config   `json:"merge"`
	Docs         []Document `json:"docs"`
}

type Config struct {
	Mode             Mode    `json:"mode"`
	ExistingAsMaster bool    `json:"existingAsMaster"`
	Type             string  `json:"type,omitempty"`
	LinkKey          string  `json:"linkKey,omitempty"`
	Groups           []Group `json:"groups,omitempty"`
}

type ConsumerProcessor interface {
	Process(message *sarama.ConsumerMessage)
}

type DecodedKafkaMessage struct {
	Data map[string]interface{}
}

type DefaultConsumer struct {
	Ready chan bool
	// contains filtered or unexported fields
}

type DefaultMultiConsumer struct {
	Ready chan bool
	// contains filtered or unexported fields
}

type Document struct {
	ID        string                 `json:"id"`
	Index     string                 `json:"index"`
	IndexType string                 `json:"type"`
	Source    map[string]interface{} `json:"source"`
}

type FieldMath struct {
	Expression  string `json:"expression"`
	OutputField string `json:"outputField"`
}

type FilterHeaderOption struct {
	Key       string
	Value     string
	Values    []string
	Condition string
}

type FilteredJsonMessage struct {
	Data map[string]interface{}
}

type FormatToBIRs func([]Message) []*BulkIngestRequest

type Group struct {
	Condition             string      `json:"condition,omitempty"`
	FieldReplace          []string    `json:"fieldReplace,omitempty"`
	FieldReplaceIfMissing []string    `json:"fieldReplaceIfMissing,omitempty"`
	FieldMerge            []string    `json:"fieldMerge,omitempty"`
	FieldMath             []FieldMath `json:"fieldMath,omitempty"`
	FieldKeepLatest       []string    `json:"fieldKeepLatest,omitempty"`
	FieldKeepEarliest     []string    `json:"fieldKeepEarliest,omitempty"`
	FieldForceUpdate      []string    `json:"fieldForceUpdate,omitempty"`
}

type JSONMapper struct {
	// contains filtered or unexported fields
}

type JSONMapperConfigItem struct {
	Mandatory    bool
	FieldType    string
	DefaultValue interface{}
	DateFormat   string
	Paths        [][]string
	OtherPaths   [][]string
	ArrayPath    []string
	Separator    string
}

type JSONMapperFilterItem struct {
	Keep         bool
	FieldType    string
	DefaultValue string
	Paths        [][]string
	Condition    string
	Value        string
	Values       []string
	Separator    string
}

type JSONMapperJsoniter struct {
	// contains filtered or unexported fields
}

type KafkaMessage struct {
	Data []byte
}

type Lookup func(path string, value string, index string) ([]string, error)

type Mapper interface {
	// FilterDocument checks if document is filtered or not, returns if documents valid and if invalid,
	// the following reason. It is using the given filters.
	FilterDocument(msg Message) (bool, string)

	// MapToDocument Maps data to document
	MapToDocument(msg Message) (Message, error)

	// DecodeDocument is a function that just decodes a document and returns it
	// You can use it if you want to decode a message only "once" and not in each
	// individual function
	DecodeDocument(msg Message) (Message, error)
}

type Message interface {
	String() string
}

type MessageWithOptions struct {
	Data    map[string]interface{}
	Options map[string]interface{}
}

type Mode int

type Processor interface {
	Process(msg Message) ([]Message, error)
}

type Reloader struct {
	// contains filtered or unexported fields
}

type Restarter struct {
	// contains filtered or unexported fields
}

type SaramaDebugLogger struct {
	// contains filtered or unexported fields
}

type SaramaLogger struct {
	// contains filtered or unexported fields
}

type Sink interface {
	AddMessageToQueue(message Message)
}

type Transformer interface {
	Transform(Message) (Message, error)
}

type TypedDataMessage struct {
	Strings map[string]string
	Ints    map[string]int64
	Bools   map[string]bool
	Times   map[string]time.Time
}