ik

type Config struct {
	Root *ConfigElement
}

type ConfigElement struct {
	Name  string
	Args  string
	Attrs map[string]string
	Elems []*ConfigElement
}

type ContinueType struct{}

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

type DefaultOpener http.Dir

type Disposable interface {
	Dispose() error
}

type Engine interface {
	Disposable
	Logger() Logger
	Opener() Opener
	LineParserPluginRegistry() LineParserPluginRegistry
	RandSource() rand.Source
	Scorekeeper() *Scorekeeper
	DefaultPort() Port
	Spawn(Spawnee) error
	Launch(PluginInstance) error
	SpawneeStatuses() ([]SpawneeStatus, error)
	PluginInstances() []PluginInstance
	RecurringTaskScheduler() *task.RecurringTaskScheduler
}

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

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

type FluentRecord struct {
	Tag       string
	Timestamp uint64
	Data      map[string]interface{}
}

type FluentRecordSet struct {
	Tag     string
	Records []TinyFluentRecord
}

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

type Input interface {
	PluginInstance
	Port() Port
}

type InputFactory interface {
	Plugin
	New(engine Engine, config *ConfigElement) (Input, error)
}

type InputFactoryRegistry interface {
	RegisterInputFactory(factory InputFactory) error
	LookupInputFactory(name string) InputFactory
}

type IntVector []int

type Journal interface {
	Disposable
	Key() string
	Write(data []byte) error
	GetTailChunk() JournalChunk
	AddNewChunkListener(JournalChunkListener)
	AddFlushListener(JournalChunkListener)
	Flush(func(JournalChunk) error) error
}

type JournalChunk interface {
	Disposable
	GetReader() (io.Reader, error)
	GetNextChunk() JournalChunk
	TakeOwnership() bool
}

type JournalChunkListener func(JournalChunk) error

type JournalGroup interface {
	Disposable
	GetJournal(key string) Journal
	GetJournalKeys() []string
}

type JournalGroupFactory interface {
	GetJournalGroup() JournalGroup
}

type LineParser interface {
	Feed(line string) error
}

type LineParserFactory interface {
	New(receiver func(FluentRecord) error) (LineParser, error)
}

type LineParserFactoryFactory func(engine Engine, config *ConfigElement) (LineParserFactory, error)

type LineParserPlugin interface {
	Name() string
	OnRegistering(func(name string, factory LineParserFactoryFactory) error) error
}

type LineParserPluginRegistry interface {
	RegisterLineParserPlugin(plugin LineParserPlugin) error
	LookupLineParserFactoryFactory(name string) LineParserFactoryFactory
}

type LineReader interface {
	Next() (string, error)
	Close() error
	Filename() string
	LineNumber() int
}

type Logger interface {
	Critical(format string, args ...interface{})
	Error(format string, args ...interface{})
	Warning(format string, args ...interface{})
	Notice(format string, args ...interface{})
	Info(format string, args ...interface{})
	Debug(format string, args ...interface{})
}

type Markup struct {
	Chunks []MarkupChunk
}

type MarkupAttributes int

type MarkupChunk struct {
	Attrs MarkupAttributes
	Text  string
}

type NotFoundType struct{}

type Opener interface {
	FileSystem() http.FileSystem
	BasePath() string
	NewOpener(path string) Opener
}

type Output interface {
	PluginInstance
	Port
}

type OutputFactory interface {
	Plugin
	New(engine Engine, config *ConfigElement) (Output, error)
}

type OutputFactoryRegistry interface {
	RegisterOutputFactory(factory OutputFactory) error
	LookupOutputFactory(name string) OutputFactory
}

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

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

type Plugin interface {
	Name() string
	BindScorekeeper(*Scorekeeper)
}

type PluginInstance interface {
	Spawnee
	Factory() Plugin
}

type PluginRegistry interface {
	Plugins() []Plugin
}

type Port interface {
	Emit(recordSets []FluentRecordSet) error
}

type RecordPacker interface {
	Pack(record FluentRecord) ([]byte, error)
}

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

type ScoreValueFetcher interface {
	PlainText(PluginInstance) (string, error)
	Markup(PluginInstance) (Markup, error)
}

type Scoreboard interface {
	PluginInstance
}

type ScoreboardFactory interface {
	Plugin
	New(engine Engine, pluginRegistry PluginRegistry, config *ConfigElement) (Scoreboard, error)
}

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

type ScorekeeperTopic struct {
	Plugin      Plugin
	Name        string
	DisplayName string
	Description string
	Fetcher     ScoreValueFetcher
}

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

type SlicerNewKeyEventListener func(last Journal, next Journal) error

type Spawnee interface {
	Run() error
	Shutdown() error
}

type SpawneeStatus struct {
	Id         int
	Spawnee    Spawnee
	ExitStatus error
}

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

type StringVector []string

type TinyFluentRecord struct {
	Timestamp uint64
	Data      map[string]interface{}
}