processor

type BatchConfig struct {
	// Partition never merges rows whose values differ here, whatever the
	// timestamps say. Naming a column no row has is not an error: every row
	// reads empty, so the partition simply never splits.
	Partition []string `json:"partition,omitempty" yaml:"partition,omitempty"`

	// Column is the timestamp read by the default grouping rule. When empty the
	// first of timestamp/@timestamp/time/firstObserved/startTime present on the
	// first row is used.
	Column string `json:"column,omitempty" yaml:"column,omitempty"`

	// Window buckets the timestamp before comparing it. Zero compares exact
	// values, which is what groups the lines of one log flush together.
	Window types.Duration `json:"window,omitempty" yaml:"window,omitempty"`

	// Order declares how the rows are sorted on the way in: "asc" (default) or
	// "desc".
	Order string `json:"order,omitempty" yaml:"order,omitempty"`

	// Boundary is a CEL predicate over `row`, `prev` and `index` that returns
	// true when row starts a new batch. Setting it replaces the timestamp rule
	// entirely, for sources whose timestamps cannot group anything.
	Boundary string `json:"boundary,omitempty" yaml:"boundary,omitempty"`

	// Continuation is a CEL predicate over the same bindings that returns true
	// when row continues the batch above it. It vetoes the timestamp rule, so a
	// stack frame still folds in when the shipper stamped it a millisecond late.
	Continuation string `json:"continuation,omitempty" yaml:"continuation,omitempty"`

	// Max caps the rows in one batch (default 1000); the batch is closed at the
	// cap.
	Max int `json:"max,omitempty" yaml:"max,omitempty"`

	// When gates the transform: batches it rejects pass through untouched. Its
	// bindings are the batch scope below.
	When string `json:"when,omitempty" yaml:"when,omitempty"`

	// Keep chooses the row the merged row is built from: "first" (default) or
	// "last".
	Keep string `json:"keep,omitempty" yaml:"keep,omitempty"`

	// Set overrides columns on the merged row. Each value is a CEL expression
	// over the batch scope: `batch` (the rows, oldest first), `first`, `last`,
	// `count` and `row` (the kept row, unmodified while Set is evaluated, so the
	// result does not depend on map ordering).
	//
	// Iterating the batch needs `dyn(batch).map(...)` rather than
	// `batch.map(...)`: gomplate declares every expression variable as
	// cel.AnyType, and the CEL checker refuses a `google.protobuf.Any` as the
	// range of a comprehension. Indexing, `size()` and field selection need no
	// such conversion.
	Set map[string]string `json:"set,omitempty" yaml:"set,omitempty"`

	// Emit replaces Set for transforms that fan a batch out to several rows: a
	// CEL expression over the same scope returning a list of rows.
	Emit string `json:"emit,omitempty" yaml:"emit,omitempty"`
}

type DedupeConfig struct {
	// Partition is the dedup key: rows agreeing on every one of these columns
	// are one group. Required — an empty key would collapse the entire result
	// to a single row, which is never what an author means.
	Partition []string `json:"partition,omitempty" yaml:"partition,omitempty"`

	// Keep chooses which row of a group survives as the merged row: "first"
	// (default) or "last". Groups preserve arrival order, so with a newest-first
	// query "first" is the most recent occurrence.
	Keep string `json:"keep,omitempty" yaml:"keep,omitempty"`

	// When is a CEL predicate over `batch`, `first`, `last`, `count` and `row`
	// that gates the merge. A group it rejects passes through as separate rows,
	// so `count > 1` leaves non-duplicates exactly as they arrived.
	When string `json:"when,omitempty" yaml:"when,omitempty"`

	// Set assigns columns on the merged row from CEL over the same bindings —
	// `count` for how many rows collapsed, `dyn(batch)…` to reach across them.
	// Leaving it empty keeps the surviving row unchanged, which is the plain
	// "drop duplicates" behaviour.
	Set map[string]string `json:"set,omitempty" yaml:"set,omitempty"`

	// Emit replaces Set, returning the merged rows from one CEL expression.
	Emit string `json:"emit,omitempty" yaml:"emit,omitempty"`

	// Max caps how many rows one group may absorb. Rows past the cap start a
	// new group rather than being dropped.
	Max int `json:"max,omitempty" yaml:"max,omitempty"`
}

type LogParseConfig struct {
	// Format is json, logfmt, klogfmt, syslog or autodetect. Empty means
	// autodetect.
	Format string `json:"format,omitempty" yaml:"format,omitempty"`

	// Column carries the raw log body. Empty reads message.
	Column string `json:"column,omitempty" yaml:"column,omitempty"`
}

type ReconOptions struct {
	// Key is the set of columns that uniquely identify a row across both sets.
	// Mutually exclusive with KeyCEL.
	Key []string

	// KeyCEL derives the identity from an expression instead of column values,
	// for the cases where the identity is nested or computed. Mutually exclusive
	// with Key.
	KeyCEL string

	// Compare restricts which columns are compared for the "changed" status.
	// When empty, all non-key columns present in either row are compared.
	Compare []string
}

type ResultSet struct {
	Name string
	Rows []query.Row
}