github

type ActionsClaims struct {
	ID                string
	Expiry            time.Time
	Repository        string `json:"repository"`
	RepositoryID      string `json:"repository_id"`
	RepositoryOwnerID string `json:"repository_owner_id"`
	Ref               string `json:"ref"`
	SHA               string `json:"sha"`
	EventName         string `json:"event_name"`
	JobWorkflowRef    string `json:"job_workflow_ref"`
	RunID             string `json:"run_id"`
	RunAttempt        string `json:"run_attempt"`
}

type ActionsKeysError struct {
	Host string
	Err  error
}

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

type AgentGuidanceClient interface {
	ReadAgentGuidance(context.Context, string, string) (*ContextSetupSource, error)
	OpenContextSetup(context.Context, ContextSetupRequest) (*PullRequest, error)
}

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

type AppInfo struct {
	ID    int64
	Slug  string
	Name  string
	Owner string
	// Permissions is what the App was granted, so setup can tell the operator
	// exactly which permission is missing rather than "403".
	Permissions map[string]string
	Events      []string
	// RepositorySelection is GitHub's own word for how much of the target this
	// installation covers: "all" or "selected". It is the difference between a
	// pool that will see every repository somebody pushes to and one that
	// silently sees none of them -- the second commonest setup mistake after a
	// missing permission, and the one nothing in Zoomies could previously say
	// anything about.
	RepositorySelection string
}

type CheckoutEvidence struct {
	Version        string
	Basis          string
	Repository     string
	Selection      CheckoutSelection
	StepNumber     int64
	BlobSHA        string
	JobNameSHA256  string
	StepNameSHA256 string
	Source         optimisation.Source
	Timing         optimisation.Timing
}

type CheckoutEvidenceReader interface {
	ReadCheckoutEvidence(context.Context, string, CheckoutSelection) (*CheckoutEvidence, error)
}

type CheckoutSelection struct {
	RunID       int64
	Attempt     int
	GitHubJobID int64
	JobIndex    int
	StepIndex   int
	// Locate asks the reader to find the one previewable checkout step in the
	// selected job from the source it reads, so nobody counts positions in a
	// file. The positions must be zero when it is set, and the evidence that
	// comes back carries the ones it found with Locate cleared.
	Locate bool
}

type Client interface {
	// Target returns the org or repo this client acts on.
	Target() (name string, kind store.TargetType)
	// Probe verifies the credentials and permissions, returning an error whose
	// message names the missing permission where GitHub tells us.
	Probe(ctx context.Context) (*AppInfo, error)
	// CreateJITConfig mints an ephemeral runner registration.
	CreateJITConfig(ctx context.Context, req JITRequest) (*JITConfig, error)
	// CreateRegistrationToken mints a one-hour token for config.sh.
	CreateRegistrationToken(ctx context.Context) (*RegistrationToken, error)
	// CreateRemoveToken mints a token for deregistering a runner from the host.
	CreateRemoveToken(ctx context.Context) (*RegistrationToken, error)
	// ListRunners returns every self-hosted runner registered on the target.
	ListRunners(ctx context.Context) ([]Runner, error)
	// DeleteRunner removes a registration. Deleting one that is already gone
	// returns nil, because the desired end state has been reached.
	DeleteRunner(ctx context.Context, id int64) error
	// ListRunnerGroups returns the target's runner groups.
	ListRunnerGroups(ctx context.Context) ([]RunnerGroup, error)
	// CreateRunnerGroup creates an organisation runner group. Repository
	// targets reject it because GitHub only supports groups at organisation
	// scope.
	CreateRunnerGroup(ctx context.Context, req RunnerGroupCreate) (*RunnerGroup, error)
	// ListQueuedJobs is the webhook fallback: it walks recent workflow runs and
	// returns the jobs still waiting for a runner and the ones running on one.
	// Status tells the two apart.
	ListQueuedJobs(ctx context.Context) ([]QueuedJob, error)
	// GetWorkflowJob reconciles a known job even after its run has completed.
	GetWorkflowJob(ctx context.Context, repo string, id int64) (*WorkflowJobEvent, error)
	// GetWorkflowRun reads the run-level status used to distinguish one
	// cancelled job from cancellation of the entire workflow run.
	GetWorkflowRun(ctx context.Context, repo string, runID int64) (*WorkflowRunState, error)
	// CancelWorkflowRun asks GitHub to cancel the entire run containing a job.
	// Force bypasses conditions that may otherwise keep a run cancelling.
	CancelWorkflowRun(ctx context.Context, repo string, runID int64, force bool) error
	// RerunWorkflowJob asks GitHub to run one job again, together with any
	// job that declares it in `needs`. It is the narrower of the two and the
	// one to reach for: a job re-run on its own account should not drag the
	// rest of the run's failures with it.
	RerunWorkflowJob(ctx context.Context, repo string, jobID int64) error
	// RerunFailedWorkflowJobs asks GitHub to run a run's failed jobs again.
	// Like cancellation it is run-level: GitHub reruns the failed jobs of a
	// run together, so a caller must be clear about what else goes with it.
	// It is the fallback for a job whose GitHub job ID this fleet never saw.
	RerunFailedWorkflowJobs(ctx context.Context, repo string, runID int64) error
	// RateLimit reports remaining quota.
	RateLimit(ctx context.Context) (*RateLimit, error)
	// WebURL returns the browser URL for the target.
	WebURL() string

	// ListRepositories returns the repositories this installation can see.
	ListRepositories(ctx context.Context, limit int) ([]Repository, error)
	// ListWorkflows returns the workflow files at the top of a repository's
	// .github/workflows, with their contents.
	ListWorkflows(ctx context.Context, repo string) ([]WorkflowFile, error)
	// ReadReadme returns the README GitHub renders on the repository's front
	// page, or ErrNoReadme when there is none. It is where the badge goes.
	ReadReadme(ctx context.Context, repo string) (*Readme, error)
	// OpenPullRequest commits a set of files to a new branch and opens a pull
	// request for it.
	OpenPullRequest(ctx context.Context, req PullRequestRequest) (*PullRequest, error)
}

type ContextIngestionClient interface {
	ReadContextPublication(context.Context, string, string) (*ContextPublication, error)
	ContextSetupMerged(context.Context, string, int, string) (bool, error)
	VerifyContextSnapshot(ctx context.Context, repo, branch, commit string, snapshot *aicontext.Snapshot) error
}

type ContextPublication struct {
	Source       *ContextSetupSource
	OutputCommit string
	Snapshot     *aicontext.Snapshot
}

type ContextRun struct {
	ID        int64
	URL       string
	CreatedAt time.Time
	UpdatedAt time.Time
	Facts     aicontext.RunFacts
	// JobIDs are GitHub's ids for Facts.Jobs, in the same order.
	JobIDs []int64
}

type ContextRunReader interface {
	// LatestContextRun is the most informative run of the managed workflow for a
	// commit, or nil when it has none.
	LatestContextRun(ctx context.Context, repo, commit string) (*ContextRun, error)
	// ContextJobErrors is the error lines of one job's log, bounded. It is nil,
	// with no error, when the job has no log: it never started, or the log has
	// expired.
	ContextJobErrors(ctx context.Context, repo string, jobID int64) ([]string, error)
	// ContextArtifactUsage is what the repository's unexpired artifacts hold.
	ContextArtifactUsage(ctx context.Context, repo string) (*aicontext.ArtifactUsage, error)
}

type ContextSetupClient interface {
	ReadContextSetup(context.Context, string, string) (*ContextSetupSource, error)
	OpenContextSetup(context.Context, ContextSetupRequest) (*PullRequest, error)
}

type ContextSetupRequest struct {
	Action     string
	Repo       string
	Base       string
	BaseCommit string
	Head       string
	PlanHash   string
	Files      []aicontext.SetupChange
}

type ContextSetupSource struct {
	Repository Repository
	Commit     string
	Inventory  []string
	Files      []aicontext.SetupFile
}

type ContextSetupStatusClient interface {
	ContextSetupStatus(context.Context, string, int, string) (string, error)
}

type ContextWorkflowDispatcher interface {
	DispatchContextWorkflow(ctx context.Context, repo, branch string) error
}

type ExperimentAttemptEvidence struct {
	WorkflowSource *ExperimentWorkflowSource `json:"workflow_source,omitempty"`
	// These are descriptive attempt metadata, not workflow contents or inputs.
	Event        string                 `json:"event,omitempty"`
	WorkflowPath string                 `json:"workflow_path,omitempty"`
	Repository   string                 `json:"repository"`
	RunID        int64                  `json:"run_id"`
	Attempt      int                    `json:"attempt"`
	HeadSHA      string                 `json:"head_sha"`
	WorkflowID   int64                  `json:"workflow_id"`
	Status       string                 `json:"status"`
	Conclusion   string                 `json:"conclusion"`
	RunStartedAt *time.Time             `json:"run_started_at"`
	UpdatedAt    *time.Time             `json:"updated_at"`
	JobsCoverage string                 `json:"jobs_coverage"`
	Jobs         []ExperimentAttemptJob `json:"jobs"`
}

type ExperimentAttemptJob struct {
	ID          int64      `json:"id"`
	Status      string     `json:"status"`
	Conclusion  string     `json:"conclusion"`
	StartedAt   *time.Time `json:"started_at"`
	CompletedAt *time.Time `json:"completed_at"`
}

type ExperimentAttemptReader interface {
	ReadExperimentAttempt(context.Context, string, int64, int) (*ExperimentAttemptEvidence, error)
}

type ExperimentWorkflowSource struct {
	Dependencies  *workflow.DependencyInventory `json:"dependencies,omitempty"`
	Version       string                        `json:"version"`
	Basis         string                        `json:"basis"`
	CommitSHA     string                        `json:"commit_sha"`
	Path          string                        `json:"path"`
	BlobSHA       string                        `json:"blob_sha"`
	ContentSHA256 string                        `json:"content_sha256"`
	Bytes         int                           `json:"bytes"`
}

type Factory interface {
	For(ctx context.Context, inst *store.Installation, privateKeyPEM []byte) (Client, error)
}

type FakeActionsIssuer struct {
	URL string
	// contains filtered or unexported fields
}

type FakeActionsSettings struct {
	// DefaultTokenWrite makes the default workflow token read and write.
	DefaultTokenWrite bool
	// ForkApproval is the approval policy word for a public repository; empty
	// is "first_time_contributors".
	ForkApproval string
	// The three answers for a private repository's fork pull requests.
	PrivateForkRuns, PrivateForkSecrets, PrivateForkWriteToken bool
}

type FakeArtifact struct {
	Name    string
	Bytes   int64
	Expired bool
}

type FakeContextJob struct {
	Name       string
	Conclusion string
	Steps      []FakeContextStep
	// Log is the job's log. Empty means it has none, which GitHub answers with a
	// 404 for a job that never started.
	Log string
}

type FakeContextRun struct {
	// Commit is the head commit the run was for.
	Commit string
	// Status is queued, in_progress or completed; empty means completed.
	Status     string
	Conclusion string
	// Finished is when the run ended; empty means now. A test that needs a
	// failure from hours ago says so here rather than waiting for it.
	Finished time.Time
	Jobs     []FakeContextJob
}

type FakeContextStep struct{ Name, Conclusion string }

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

type FakeRequiredCheck struct {
	Context string
	AppID   int64
}

type FileChange struct {
	Path    string
	Content string
	// SHA is the blob SHA the change was computed against.
	SHA string
}

type JITConfig struct {
	// Encoded is the base64 configuration.
	Encoded string
	// RunnerID is the ID GitHub assigned, so Zoomies can delete the
	// registration later if the runner never comes up.
	RunnerID int64
	// Name echoes the requested name.
	Name string
}

type JITRequest struct {
	// Name must be unique within the target. GitHub rejects reuse.
	Name string
	// Labels are the custom labels this runner advertises, without the
	// implicit self-hosted/os/arch set.
	Labels []string
	// RunnerGroupID is 1 (Default) unless the pool names a group.
	RunnerGroupID int64
	// WorkFolder defaults to "_work".
	WorkFolder string
}

type KennelGuidanceInventory struct {
	Paths       []string
	Files       []WorkflowFileRef
	Skipped     []WorkflowFileRef
	Partial     bool
	TreePartial bool
}

type KennelGuidanceReader interface {
	KennelGuidanceInventory(context.Context, string, string) (*KennelGuidanceInventory, error)
	KennelWorkflowBlob(context.Context, string, WorkflowFileRef) ([]byte, error)
}

type KennelPrivateFork struct {
	// Runs is true when fork pull requests run workflows at all.
	Runs bool
	// Secrets is true when they are given the repository's secrets and variables.
	Secrets bool
	// WriteToken is true when they are given a token that can write.
	WriteToken bool
}

type KennelProtection struct {
	// Required are the checks pinned to the GitHub Actions app, from every source
	// that requires them, sorted and without repeats. They are names a
	// repository chose, so the controller compares them with job names and keeps
	// them out of every sentence.
	Required []string
	// Unpinned counts the required checks that name no app or another one, or
	// that one source leaves open to any app. They are counted and never judged.
	Unpinned int
	// Partial is set when one half could not be read or a limit was reached, so
	// the list may be short.
	Partial bool
}

type KennelRun struct {
	ID int64
	// Event is GitHub's name for what triggered the run, bounded to 64 bytes. The
	// controller passes it through an allow-list before anything sees it.
	Event string
	// RepositoryID is the repository the run ran in; HeadRepositoryID is the one
	// its head commit is in. They differ for a pull request from a fork, and a
	// fork that has since been deleted has no head repository at all, which reads
	// as zero.
	RepositoryID     int64
	HeadRepositoryID int64
}

type KennelSettings struct {
	// DefaultTokenWrite is true when the default workflow token can write.
	DefaultTokenWrite bool
	// ForkApproval is GitHub's approval policy for a fork pull request from an
	// outside contributor, for a public repository. It is empty when the policy
	// was not read: a private repository, or a GitHub that lacks the endpoint.
	ForkApproval string
	// PrivateFork says what a private repository does with fork pull requests.
	// It is nil for a public repository and when GitHub lacks the endpoint.
	PrivateFork *KennelPrivateFork
	// Partial is set when an endpoint this GitHub does not offer was left out, so
	// a finding that needed it cannot be judged.
	Partial bool
}

type KennelSettingsReader interface {
	// KennelSettings reads the Actions settings that govern a workflow's token
	// and a fork's approval. public says which fork policy applies: a public
	// repository has an approval policy, and a private one has the rules for
	// fork pull requests. An internal repository is read as private.
	KennelSettings(ctx context.Context, repo string, public bool) (*KennelSettings, error)
	// KennelProtection reads the status checks a branch requires, from classic
	// branch protection and from the rules that apply to the branch. Both are
	// read, because a repository protected one way looks unprotected to a reader
	// of the other.
	KennelProtection(ctx context.Context, repo, branch string) (*KennelProtection, error)
}

type KennelSetup struct {
	Present         map[string]bool
	HasDependencies bool
	Partial         bool
}

type KennelSetupReader interface {
	KennelSetup(context.Context, string, string) (*KennelSetup, error)
}

type KennelWorkflowInventory struct {
	Files   []WorkflowFileRef
	Skipped []WorkflowFileRef
	Partial bool
}

type KennelWorkflowReader interface {
	KennelWorkflowInventory(context.Context, string, string) (*KennelWorkflowInventory, error)
	KennelWorkflowBlob(context.Context, string, WorkflowFileRef) ([]byte, error)
}

type ManifestCredentials struct {
	AppID int64
	Slug  string
	Name  string
	// PEM is the App's private key. It is shown once and must be sealed
	// immediately.
	PEM string
	// WebhookSecret is the secret GitHub generated for the App's webhook. It
	// is the only copy: the manifest cannot ask for a particular one, and
	// GitHub does not show it again.
	WebhookSecret string
	ClientID      string
	ClientSecret  string
	HTMLURL       string
}

type ManifestOptions struct {
	// Name is the App's display name, unique across all of GitHub.
	Name string
	// URL is the App's homepage, shown on its GitHub page.
	URL string
	// WebhookURL is where GitHub delivers workflow_job events.
	WebhookURL string
	// Organization is the org the App is created under. Empty creates it on
	// the operator's own account, which is the right choice for repo targets.
	Organization string
	// SetupURL is permanent App configuration: GitHub sends the operator here
	// after every future install or reconfiguration of the App -- adding a
	// repository to the installation, most commonly, years later. It has to be
	// an address that still answers then.
	SetupURL string
	// RedirectURL is where GitHub returns during *this* handshake, carrying
	// ?code=. Empty means "the same as SetupURL", which is right when the
	// handshake is driven from the controller's own web UI.
	//
	// They are separate because the installer is not: it catches the callback
	// on a temporary loopback listener that is gone minutes later, and writing
	// that ephemeral port into setup_url left every App `zoomies init` ever
	// created sending its operator to a refused connection.
	RedirectURL string
	// Public allows the App to be installed on accounts other than the one
	// that created it. Zoomies defaults it off: a fleet controller's App has
	// no business being installable by strangers.
	Public bool
	// AllowWorkflowCancellation raises Actions from read to write so Zoomies
	// can cancel workflow runs. It is opt-in because write is not needed to run
	// the fleet.
	AllowWorkflowCancellation bool
	// Migration adds the three repository permissions the migration wizard needs
	// to rewrite a runs-on line and open a pull request for it: contents,
	// pull_requests and workflows, all at write. It is opt-in because nothing
	// else in Zoomies writes to a repository, so an App that carries them by
	// default hands every installation write access to code and to CI workflows
	// for a feature most of them will never use.
	Migration bool
	// KennelSettings adds Administration read to an organisation App, for the
	// Kennel Club checks that read a repository's Actions settings and the status
	// checks its default branch requires (kennel.settings_checks). GitHub offers
	// no narrower permission for those settings, and it also lets an App read a
	// repository's collaborators and configuration, which Kennel Club does not
	// use, so it is asked for only when the operator says they want those checks.
	// A repository App already holds Administration write, which includes read,
	// so the option changes nothing for one.
	KennelSettings bool
	// KennelFiles adds Contents read, for the Kennel Club checks that read a
	// repository's file inventory, its workflow files and its agent instruction
	// files (kennel.repository_setup, kennel.workflow_checks and
	// kennel.agent_guidance). A public repository needs none of it, and a private
	// one is a coverage gap without it. It is asked for only when the operator says
	// they want those checks, because read access to contents is read access to the
	// code. It is not lowered when Migration already holds Contents write.
	KennelFiles bool
}

type PRDelayCheck struct {
	ID            int64
	SuiteID       int64
	AppID         int64
	Name          string `json:"-"`
	WorkflowRunID int64
	WorkflowJobID int64
	HeadSHA       string
	Status        string
	Conclusion    string
	StartedAt     *time.Time
	CompletedAt   *time.Time
}

type PRDelayEvidence struct {
	Number              int
	HeadSHA             string
	CurrentHeadSHA      string
	TargetBranch        string
	CurrentTargetBranch string
	Open                bool
	StillOpen           bool
	Protection          *KennelProtection `json:"-"`
	ProtectionCoverage  string
	ChecksCoverage      string
	Checks              []PRDelayCheck
}

type PRDelayReader interface {
	ReadPRDelay(context.Context, string, int) (*PRDelayEvidence, error)
}

type PullRequest struct {
	Number  int    `json:"number"`
	HTMLURL string `json:"html_url"`
	Branch  string `json:"branch"`
}

type PullRequestRequest struct {
	// Repo is "owner/name".
	Repo string
	// Base is the branch to open against. Empty means the default branch.
	Base string
	// Head is the branch to create. It must not already exist.
	Head          string
	Title         string
	Body          string
	CommitMessage string
	Files         []FileChange
}

type QueuedJob struct {
	ID    int64
	RunID int64
	// RunNumber is GitHub's own sequential number for the workflow run --
	// free from the same run listing this job was found in, unlike the
	// webhook path, which has to ask for it separately.
	RunNumber    int64
	Repo         string
	WorkflowName string
	JobName      string
	Labels       []string
	QueuedAt     time.Time
	HTMLURL      string
	// RunnerName is set once GitHub has assigned the job.
	RunnerName  string
	Status      string
	Conclusion  string
	StartedAt   *time.Time
	CompletedAt *time.Time
}

type RateLimit struct {
	Limit     int
	Remaining int
	ResetAt   time.Time
}

type RateLimitedError struct {
	// ResetAt is when the quota refills, zero when GitHub did not say.
	ResetAt time.Time
	// RetryAfter is the secondary limit's answer, which is a duration rather
	// than an instant. Zero when unset.
	RetryAfter time.Duration
	Detail     string
}

type Readme struct {
	// Path is repository-relative -- "README.md", but also "readme.markdown"
	// or "README.rst", which is why the caller checks it before writing
	// Markdown into it.
	Path string
	// SHA is the blob SHA, for the same reason a workflow file carries one.
	SHA string
	// Content is the decoded file.
	Content string
}

type RegistrationToken struct {
	Token     string
	ExpiresAt time.Time
}

type RepairActor struct {
	ID       int64
	Login    string
	CanWrite bool
}

type RepairClient interface {
	RepairActor(context.Context, string, string) (RepairActor, error)
	RepairPull(context.Context, string, int) (RepairPull, error)
	RepairPullForRun(context.Context, string, int64) (RepairPull, error)
	RepairSource(context.Context, string, RepairPull, bool) (*RepairSource, error)
	RepairFailures(context.Context, string, RepairPull, int64) ([]string, error)
	CommitRepair(context.Context, string, RepairPull, prrepair.Plan) (string, error)
	RepairComment(context.Context, string, int, int64, string) (int64, error)
	RepairReact(context.Context, string, int64, string) error
	RepairChecks(context.Context, string, string) (string, error)
}

type RepairPull struct {
	Number   int
	AuthorID int64
	Author   string
	Branch   string
	// Base is the branch the pull request merges into, which is not always the
	// repository's default branch: it can target a release branch.
	Base          string
	HeadSHA       string
	Title         string
	Body          string
	URL           string
	DefaultBranch string
	Fork          bool
	Open          bool
}

type RepairSource struct {
	Snapshot prrepair.Snapshot
	// contains filtered or unexported fields
}

type RepairTargetChanged struct {
	Code    string
	Message string
}

type RepoReader interface {
	// KennelRepositories lists the repositories the installation can see, through
	// the conditional client: Kennel Club asks again every refresh, and a listing
	// GitHub says is unchanged costs nothing against the rate limit.
	KennelRepositories(ctx context.Context, limit int) ([]Repository, error)
	// KennelRun reads four fields of one workflow run, and no others.
	KennelRun(ctx context.Context, repo string, runID int64) (*KennelRun, error)
}

type Repository struct {
	ID            int64  `json:"id"`
	FullName      string `json:"full_name"`
	DefaultBranch string `json:"default_branch"`
	Private       bool   `json:"private"`
	Archived      bool   `json:"archived"`
	HTMLURL       string `json:"html_url"`
	// Visibility is "public", "private" or "internal". GitHub sends it with every
	// repository; an older GitHub Enterprise Server that does not is read from
	// Private instead, so it is never empty.
	Visibility string `json:"visibility"`
}

type Runner struct {
	ID     int64
	Name   string
	OS     string
	Status string // online | offline
	Busy   bool
	Labels []string
	// Ephemeral is reported by GitHub for JIT-configured runners.
	Ephemeral bool
}

type RunnerGroup struct {
	ID         int64
	Name       string
	Default    bool
	Visibility string
	// PublicRepositoryAccessKnown distinguishes an older GitHub Enterprise
	// response that omitted the setting from a group that explicitly disables
	// it. Treating both as false would raise a warning nobody could act on.
	PublicRepositoryAccessKnown bool
	AllowsPublicRepositories    bool
	RestrictedToWorkflows       bool
}

type RunnerGroupCreate struct {
	Name                     string
	Visibility               string
	AllowsPublicRepositories bool
}

type WorkflowFile struct {
	// Path is repository-relative.
	Path string
	// SHA is the blob SHA. GitHub requires it to update the file, and it is
	// what makes an update fail rather than clobber somebody's change.
	SHA string
	// Content is the decoded file.
	Content string
}

type WorkflowFileRef struct {
	SHA  string
	Size int
	Path string
}

type WorkflowJobEvent struct {
	// Action is "queued", "in_progress", "completed" or "waiting".
	Action string
	// InstallationID routes the delivery to one of Zoomies' installations.
	InstallationID int64

	JobID        int64
	RunID        int64
	Repo         string // "acme/widgets"
	WorkflowName string
	JobName      string
	// Labels are the workflow's runs-on values, including implicit ones.
	Labels     []string
	RunnerID   int64
	RunnerName string
	Status     string
	Conclusion string

	// QueuedAt is the job's created_at, i.e. when GitHub started looking for a
	// runner.
	QueuedAt    time.Time
	StartedAt   time.Time
	CompletedAt time.Time
	HTMLURL     string

	// HeadBranch, HeadSHA and RunAttempt say what the job ran for.
	HeadBranch string
	HeadSHA    string
	RunAttempt int
	// Steps are the job's steps as this delivery reports them. On a completed
	// delivery every step carries its conclusion, which is what lets a failed
	// job say where it failed.
	Steps []store.JobStep
}

type WorkflowRunState struct {
	Status     string
	Conclusion string
	// RunNumber is the "#1009" GitHub's Actions UI shows next to the workflow
	// name. workflow_job deliveries never carry it, which is what this lookup
	// is for.
	RunNumber int64
	// Event is what started the run: push, pull_request, schedule and so on.
	Event string
}