match

type Extra struct {
	// Exchange is its position in the observation.
	Exchange int
	// AfterStep is the index of the scenario step it followed, or -1 when
	// it came before the first matched step.
	AfterStep int
}

type Found struct {
	Instance
	// Rank is the instance's rank among the candidates at its point.
	Rank Rank
	// RunnerUp is the next-best candidate scenario at that point, with its
	// rank; empty when there was none.
	RunnerUp     string
	RunnerUpRank Rank
}

type Instance struct {
	Scenario string
	Steps    []StepResult
	Extra    []Extra
	// Score is the alignment's total score, match bonuses included.
	Score int
	// Explained is the number of exchanges matched to steps.
	Explained int
	// Counts of step outcomes. Strong and Weak count matched steps.
	Matched, Strong, Weak, NotSeen, Skipped, Unmatchable, Unobservable int
}

type Kind int

type Options struct {
	// Scenarios names the scenarios to look for, in order. When empty,
	// every scenario that is not a fragment is a candidate at each point.
	Scenarios []string
	// From and To limit matching to exchanges in a time range. Exchanges
	// without a time are kept.
	From, To *time.Time
}

type Outcome int

type Rank struct {
	Net, Strong, Score int
}

type Report struct {
	// Instances are the scenario instances found, in order.
	Instances []Found
	// Outside are the positions of exchanges in the window that fall in no
	// instance.
	Outside []int
	// LeftOut is the number of exchanges outside the time window.
	LeftOut int
	// Warnings are notes for the document's or binding's author, each once,
	// however many scenarios include the step.
	Warnings []Warning
}

type Resolved struct {
	// Index is the exchange's position in the observation.
	Index int
	// Exchange is the observed exchange.
	Exchange *pidl.Exchange
	// URL is the request URL after the binding's rewrites; Host and Path
	// are its parts.
	URL, Host, Path string
	// From and To are participant IDs; empty when the binding cannot
	// resolve them.
	From, To string
}

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

type Status string

type Step struct {
	// Index is the step's position in the scenario's Steps.
	Index int
	// Step is the walkthrough step.
	Step *pidl.WalkthroughStep
	// Kind classifies the step.
	Kind Kind
	// Rule is the step's rule; meaningful when HasRule.
	Rule pidl.StepMatch
	// HasRule reports that the step can be matched: a request step, or a
	// standalone step with a document or binding rule.
	HasRule bool
	// RuleSources names where the rule's fields came from, in the order
	// they were applied: "example", "document", "binding <key>", "binding
	// path <key>".
	RuleSources []string
	// PairedWith is the index of the request step a response step belongs
	// to, and -1 for other kinds.
	PairedWith int
}

type StepResult struct {
	Step     Step
	Status   Status
	Strength Strength
	// Exchanges are the positions, in the observation, of the exchanges
	// matched to the step: one, several for a repeated step, and for a
	// response step its request step's.
	Exchanges []int
	// Score is the match's score, before the match bonus.
	Score int
}

type Strength string

type Tests struct {
	// Participants and Method are the required tests.
	Participants, Method Outcome
	// SenderKnown reports that the exchange's sender resolved and agreed,
	// not merely that it was unknown.
	SenderKnown bool
	// Path, Status, Headers and Body are the scored tests.
	Path, Status, Headers, Body Outcome
}

type Warning struct {
	Scenario string
	Step     string
	Message  string
}