rules

type Action struct {
	Type   string `json:"type"`
	Folder string `json:"folder,omitempty"`
}

type Cond struct {
	All   []Cond `json:"all,omitempty"`
	Any   []Cond `json:"any,omitempty"`
	Field string `json:"field,omitempty"`
	Op    string `json:"op,omitempty"`
	Value any    `json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Defaults struct {
	DecisionModel string   `yaml:"decision_model,omitempty"`
	FallbackModel string   `yaml:"fallback_model,omitempty"`
	MinConfidence *float64 `yaml:"min_confidence,omitempty"`
}

type Draft struct {
	// Instruction is how the reply should sound or what it should say ("polite no"); empty =
	// the model's own judgement.
	Instruction string `json:"instruction" yaml:"instruction,omitempty"`
	// ReadPrevious also hands the model the thread's previous message, when it is found.
	ReadPrevious bool `json:"read_previous" yaml:"read_previous,omitempty"`
}

type Evaluation struct {
	Final      *Result
	Candidates []Rule // passing intent rules above the cut-off, in priority order
	CutOff     *Rule  // the default when the decider picks none; may be nil
	// contains filtered or unexported fields
}

type Field struct {
	Name string
	Type string   // string | boolean | number | pass, fail or none | account id
	Ops  []string // the operators it accepts
}

type File struct {
	Defaults Defaults
	// Rules are as the file has them: an account condition names each mailbox by its
	// address (a string), not by its id, for the same reason as Mailboxes.
	Rules []Rule
	// Mailboxes says which mailbox each rule applies to, by the rule's name: the mailbox's
	// address (its login), or AllMailboxes. A rule with no entry says nothing about it. A
	// file cannot hold numeric account ids, which differ from one install to the next, so
	// whoever has the accounts maps the address to Rule.AccountID and back.
	Mailboxes map[string]string
}

type Options struct {
	MinConfidence float64   // threshold for rules that set none
	Now           time.Time // for age_days
	// RouteOnly are rules a sender rule may route to although they take no part in the
	// walk: a manual run of only some rules leaves the others out of the walk, yet the
	// user's standing sender answers still apply (MAI-43). nil in live sorting.
	RouteOnly []Rule
}

type Result struct {
	Stage       Stage
	RuleID      int64 // 0 = no rule; with Review, the rule the decider suggested
	RuleVersion int
	Confidence  float64
	Actions     []Action // the primary rule's actions, then each stacking rule's
	Stacked     []int64  // stacking rules whose actions were appended
	Review      bool     // below threshold: take no action, show in Needs review
	// SenderRuleID is the sender rule that settled the email (Stage is StageSender), and
	// SenderSource who made it (user | learned); 0 and empty otherwise.
	SenderRuleID int64
	SenderSource string
}

type Rule struct {
	ID            int64
	UserID        int64
	AccountID     int64 // 0 = all accounts
	Name          string
	Said          string // the user's original wording; "" when they gave none
	Template      string // the name of the gallery template it was added from; "" = none
	Intent        string // plain-English intent for the decider; "" = condition-only
	Conditions    Cond
	Exceptions    Cond // "unless"
	Actions       []Action
	Priority      int // lower runs first
	Stack         bool
	Model         string   // per-rule decider override
	MinConfidence *float64 // nil = the configured default
	Enabled       bool
	// MailboxRemoved marks a rule whose mailbox was removed (DropAccount): it is off and
	// may not be switched on until it is given a mailbox, or All mailboxes, or new
	// conditions, which clears the mark.
	MailboxRemoved bool
	// Notify are the tenant's notification destinations told each time the rule acts on an
	// email live (store notify_destinations ids); nil = none. A rules file does not carry
	// them: they name this install's destinations.
	Notify []int64
	// Draft, when set, has a reply drafted each time the rule acts on an email live (a
	// module writes it; the daemon saves it in the mailbox's Drafts folder and never sends
	// it); nil = none.
	Draft     *Draft
	Version   int
	CreatedAt int64
	UpdatedAt int64
}

type RuleError struct {
	N   int    // the rule's place in the file, from 1
	ID  string // its id (name) as written
	Err *ValidationError
}

type SenderRule struct {
	ID        int64
	UserID    int64
	MatchType string // address | domain
	Value     string // lower-case
	RuleID    int64  // for route: the rule whose actions apply; 0 otherwise
	Verdict   string // route | keep | block | move
	// Folder is where a move verdict files the sender's mail, on whichever mailbox it
	// arrives in; "" otherwise.
	Folder    string
	Source    string // user | learned
	Hits      int
	CreatedAt int64
}

type Stage string

type ValidationError struct {
	Path    string
	Message string
}