decide

type Act struct {
	ID  string `json:"id"`
	Act string `json:"act"`
	Op  string `json:"op,omitempty"`
	At  string `json:"at"`
}

type Answer struct {
	Type       string             `json:"type"`
	Value      string             `json:"value"`
	P          map[string]float64 `json:"p"`
	Confidence float64            `json:"confidence,omitempty"`
	Method     string             `json:"method,omitempty"`
}

type AnswerInput struct {
	Note   string   // the judgment's notification id
	Kind   string   // the judgment's type, as the inbox names it
	Text   string   // the judgment note's text
	Card   string   // the card answered
	Verb   string   // the verb given
	Reason string   // --reason (or the wait's duration), "" when none
	Fix    string   // --fix, "" when none
	Actor  string   // who answered
	Mark   CardMark // the card as it stood after the verb ran
}

type Backend interface {
	Name() string
	Ask(ctx context.Context, s Schema, state string) (map[string]Answer, Usage, error)
}

type BackendError struct {
	Backend string
	Err     error
}

type Bar struct {
	At              float64
	Caught, Bounced int // positives flagged; negatives flagged
}

type Bars struct {
	Bounce float64 `json:"bounce"`
	Review float64 `json:"review"`
}

type Brief struct {
	Converges float64  // p(converges)
	Minutes   string   // the minutes option chosen
	Ambiguous string   // the ambiguous_step option chosen: none, step-<n> or unnumbered
	Failed    []string // the questions the card fails: a need under 0.5 as name(p), a step as ambiguous_step:step-<n>(p)
}

type BriefBar struct {
	At  float64
	Set bool
}

type BucketRow struct {
	Grade, Bucket           string
	N, FirstFailed, Landed2 int
}

type Calibration struct {
	Decision, Schema, Question, Option string
	Positives, Negatives               []float64 // the score of each labelled decision
	Skipped                            int       // labelled otherwise, unlabelled, or asked under another schema
}

type CardFacts struct {
	State       string // landed, dropped, or the column it sits in
	Start       string
	MaxAttempt  int
	FirstFailed bool
	Escalated   bool
	// contains filtered or unexported fields
}

type CardMark struct {
	Placed, Landed, Dropped bool
	Broken, Failed          int
}

type Chosen struct {
	Verb   string  `json:"verb"`
	P      float64 `json:"p"`
	Fix    string  `json:"fix,omitempty"`    // a rework's fix option, when its command takes one
	Reason string  `json:"reason,omitempty"` // a drop's reason option
	Act    string  `json:"act"`
	Why    string  `json:"why,omitempty"` // why it is listed
}

type Class struct {
	Name, Escalations, Statement string
}

type Cluster struct {
	Class string   `json:"class"`
	Count int      `json:"count"`
	Cards []string `json:"cards"`
}

type ConflictError struct{ What string }

type Decided struct {
	Value string
	P     float64
	Op    string
}

type Decision struct {
	ID       string            `json:"id"`
	Decision string            `json:"decision"` // the schema's name
	Schema   string            `json:"schema"`   // the schema's hash
	Backend  string            `json:"backend"`
	At       string            `json:"at"` // RFC 3339, UTC
	Inputs   map[string]string `json:"inputs"`
	State    string            `json:"state"` // the exact text asked over: the training input
	Answers  map[string]Answer `json:"answers"`
	Usage    Usage             `json:"usage"`
	Outcome  *Outcome          `json:"outcome,omitempty"` // folded in on load; never written on this line
	Acts     []Act             `json:"acts,omitempty"`    // folded in on load, in order; never written on this line
}

type End struct{ Label, Note string }

type Example struct {
	Card    string `json:"card"`
	Heading string `json:"heading"`
	Paths   string `json:"paths"`
	Kind    string `json:"kind"`
	Label   string `json:"label"`
}

type Failure struct {
	Pkg   string   `json:"pkg"`
	Test  string   `json:"test,omitempty"`
	Lines []string `json:"lines,omitempty"`
}

type Fixed struct {
	Table map[string]FixedAnswer
}

type FixedAnswer struct {
	Choice string             `json:"choice,omitempty"`
	P      map[string]float64 `json:"p,omitempty"`
	Noul   *float64           `json:"noul,omitempty"`
}

type GateBars struct {
	Flaky       float64 `json:"flaky"`
	PreExisting float64 `json:"pre_existing"`
}

type GateCall struct {
	Failure  Failure
	Decision *Decision
	Route    string
	Existing bool // the decision was in the record already, and nothing was asked
}

type GateInput struct {
	Failures []Failure
	BaseRed  map[string]bool
	Paths    []string
	Diff     string // DiffSummary of the card's diff
}

type GateResult struct {
	Calls []GateCall
	Route string
}

type GradeRow struct {
	Grade, Dealt                             string
	N, Landed2, Landed, ToPro, Dropped, Open int
}

type GradeScore struct {
	Decisions, Cards, NoLog int // grade decisions in the day, the cards they grade, cards the log lacks
	Rows                    []GradeRow
	Buckets                 []BucketRow
}

type ImportCount struct{ New, Existing int }

type ImportResult struct {
	Kinds      map[string]ImportCount
	Unanswered int
}

type ImportSources struct {
	Verdicts, Judgments, Log, Reports string
}

type Item struct {
	ID     string
	State  string
	Inputs map[string]string
}

type Jev struct {
	Model string
	Send  Send
}

type JudgmentInput struct {
	Kind    string   // the judgment's type, as the inbox names it
	Text    string   // the judgment note's text
	Card    string   // the card decided
	Cards   int      // how many cards the judgment holds
	History []string // the card's log, oldest first
	Allowed []string // the verbs the judgment prints
}

type KindAgreement struct {
	Kind      string
	Count     int
	Agree     int
	Pct       int
	HighCount int
	HighAgree int
	HighPct   int
}

type LogLine struct {
	Card    string            `json:"card"`
	Primary string            `json:"primary"`
	Table   string            `json:"table"`
	To      string            `json:"to"`
	Removed bool              `json:"removed"`
	Set     map[string]string `json:"set"`
}

type Made struct {
	Decision
	Existing bool
	Err      error
}

type Outcome struct {
	ID    string `json:"id"`
	Label string `json:"label"`
	Note  string `json:"note,omitempty"`
	At    string `json:"at"`
}

type Question struct {
	Type         string            `json:"type"`
	Instructions string            `json:"instructions"`
	Criteria     map[string]string `json:"criteria,omitempty"` // choice only: option -> what it means
}

type ReadScore struct {
	Against        string
	Count          int
	TP, FP, FN, TN int
	Precision      int
	Recall         int
}

type Schema struct {
	Name      string              `json:"name"`
	Questions map[string]Question `json:"questions"`
}

type Send func(ctx context.Context, body []byte) ([]byte, error)

type Usage struct {
	InputTokens  int `json:"input_tokens"`
	OutputTokens int `json:"output_tokens"`
}