pkg

type ApiCaller interface {
	Configure(logger Logger, config *EventHandlerConfig) error
	Call(ctx context.Context, httpMethod string, url string, body []byte, headers HttpHeaders) (responseBody []byte, httpStatusCode int, err error)
	Close() error
}

type Cli struct {
	Options *Options
}

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

type EventHandlerConfig struct {
	Type    string // 'http' is the only supported type for now
	Method  string
	Url     string
	Headers HttpHeaders
}

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

type EventListenerConfig struct {
	Type           string // 'kafka' is the only supported type for now
	Topic          string
	ConsumerConfig KafkaConsumerConfig `yaml:"consumerConfig"`
}

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

type EventResultProcessorConfig struct {
	Type           string // 'kafka' is the only supported type for now
	Topic          string
	When           []string
	ProducerConfig KafkaProducerConfig `yaml:"producerConfig"`
}

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

type EventorConfig struct {
	Name                 string
	LogLevel             int
	EventListener        EventListenerConfig        `yaml:"eventListener"`
	EventHandler         EventHandlerConfig         `yaml:"eventHandler"`
	EventResultProcessor EventResultProcessorConfig `yaml:"eventResultProcessor"`
}

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

type HttpHeaders = map[string]string

type KafkaConsumerConfig = map[string]string

type KafkaMessageConsumer struct {
	Consumer *kafka.Consumer
	// contains filtered or unexported fields
}

type KafkaMessageProducer struct {
	Producer *kafka.Producer
	// contains filtered or unexported fields
}

type KafkaProducerConfig = map[string]string

type Level int

type Logger interface {
	Debug(string)
	Info(string)
	Warn(string)
	Error(string)
	Debugf(string, ...interface{})
	Infof(string, ...interface{})
	Warnf(string, ...interface{})
	Errorf(string, ...interface{})
}

type Message struct {
	Key   []byte
	Value []byte
}

type MessageConsumer interface {
	Configure(logger Logger, config *KafkaConsumerConfig, topic string) error
	Subscribe() error
	Consume(ctx context.Context) (*Message, error)
	CommitLastMessage(ctx context.Context) error
	Close() error
}

type MessageProducer interface {
	Configure(logger Logger, config *KafkaProducerConfig, topic string) error
	Produce(ctx context.Context, msg *Message) error
	Close() error
}

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

type Unmarshaller interface {
	Unmarshal(in []byte, out interface{}) error
}