alerting

type ACMEFailureSource interface {
	ACMEFailing(domain string) (errText string, failing bool)
}

type AlertContext struct {
	RuleID   string
	Kind     string
	Metric   string
	App      string
	NodeID   string
	NodeName string
	Labels   map[string]string
	Severity string
}

type AppDomainSource interface {
	GetDesiredService(ctx context.Context, name string) (*store.DesiredService, error)
}

type ApprovalRequestInfo struct {
	ApprovalID  string
	ServiceName string
	// Action is one of store.DeployApprovalAction* ("deploy" or
	// "promote"), duplicated here as a plain string so this package
	// doesn't need to import internal/store just for two constants.
	Action        string
	Image         string
	RequestedBy   string
	EnvironmentID string
}

type AutoRollbackStore interface {
	deploy.ImageDeployStore
	GetDesiredService(ctx context.Context, name string) (*store.DesiredService, error)
	ListDeployAttempts(ctx context.Context, serviceName string) ([]store.DeployAttempt, error)
}

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

type BackupCopyPending struct {
	Resource   string
	BackupID   string
	FinishedAt time.Time
	LastError  string
}

type BackupCopySource interface {
	PendingBackupCopies(ctx context.Context) ([]BackupCopyPending, error)
}

type BackupSource interface {
	GetDesiredDatabase(ctx context.Context, name string) (*store.DesiredDatabase, error)
	ListBackupHistory(ctx context.Context, databaseName string, limit int, before *time.Time) ([]store.BackupHistory, error)
	GetServiceVolumeBackupSchedule(ctx context.Context, serviceName, volumeName string) (store.ServiceVolumeBackupConfig, error)
	ListServiceVolumeBackupHistory(ctx context.Context, serviceName, volumeName string, limit int, before *time.Time) ([]store.BackupHistory, error)
}

type BudgetSource interface {
	BudgetStatuses(ctx context.Context) ([]usagecost.BudgetStatus, error)
}

type BurnTier struct {
	Name   string        `json:"name"`
	Factor float64       `json:"factor"`
	Long   time.Duration `json:"long"`
	Short  time.Duration `json:"short"`
	Page   bool          `json:"page"`
}

type BurnWindowStat struct {
	Window   time.Duration `json:"window"`
	Requests float64       `json:"requests"`
	Bad      float64       `json:"bad"`
	Burn     float64       `json:"burn_rate"`
}

type CertDeleter interface {
	DeleteCertStorageValue(ctx context.Context, key string) error
}

type CertEvalResult struct {
	Notices []string
	Facts   []CertFact
	// Superseded is true when this rule saw unhealthy certificates but a tighter rule owns them all.
	Superseded bool
}

type CertExpiryObservation struct {
	RuleID           string
	Domain           string
	Status           string
	NotAfter         time.Time
	EpisodeNotAfter  time.Time
	EpisodeStartedAt time.Time
	ObservedAt       time.Time
}

type CertExpiryObservationStore interface {
	UpsertCertExpiryObservation(ctx context.Context, o CertExpiryObservation) error
	ListCertExpiryObservations(ctx context.Context, ruleID string) ([]CertExpiryObservation, error)
}

type CertExpiryPolicy struct {
	Enabled bool
	// Windows lists every enabled cert_expiry rule window so only the tightest matching one reports a certificate.
	Windows    []time.Duration
	LastResort time.Duration
	RenewRatio float64
	// ReminderInterval is the minimum gap between reminders for a still-firing rule.
	ReminderInterval time.Duration
	ACME             ACMEFailureSource
	// BaseURL is the instance's public dashboard address used for email deep links.
	BaseURL string
}

type CertFact struct {
	Domain   string
	Issuer   string
	DaysLeft int
	Reason   string
	Action   string
	// NotAfter and FailureKind feed CertPayload.
	NotAfter    time.Time
	FailureKind string
}

type CertInfo struct {
	Domain    string
	SANs      []string
	Issuer    string
	NotBefore time.Time
	NotAfter  time.Time
	// Status is "healthy", "expiring_soon", or "expired"; see
	// CertExpiryStatus.
	Status string
	// Internal marks a self-signed or local-CA certificate the platform issues by design.
	Internal bool
}

type CertLinks struct {
	Primary      string
	PrimaryLabel string
	Inbox        string
	Settings     string
}

type CertPayload struct {
	Domain      string    `json:"domain"`
	Issuer      string    `json:"issuer,omitempty"`
	NotAfter    time.Time `json:"not_after"`
	DaysLeft    int       `json:"days_left"`
	FailureKind string    `json:"failure_kind"`
}

type CertSource interface {
	ListCertStorageKeys(ctx context.Context, prefix string, recursive bool) ([]string, error)
	GetCertStorageValue(ctx context.Context, key string) (*store.CertStorageValue, error)
}

type CertSuppressor func(ctx context.Context) func(domain string) bool

type ChangeSource interface {
	Collect(ctx context.Context, app string, until time.Time) changes.Result
}

type ChannelSecrets interface {
	SetValue(ctx context.Context, serviceName, envKey, plaintext string) error
	Resolve(ctx context.Context, serviceName, envKey string) (string, error)
	DeleteAll(ctx context.Context, serviceName string) error
}

type Comparator string

type ControlPlaneBackupSource interface {
	Newest() (time.Time, bool, error)
}

type ControlPlaneDRSource interface {
	DRProblem(now time.Time) string
}

type CostBudgetSource interface {
	CostBudgetBreaches(ctx context.Context) ([]costbudget.Breach, error)
}

type DB struct {
	*sql.DB
	// contains filtered or unexported fields
}

type DatabaseBackupSource interface {
	ListBackupHistory(ctx context.Context, databaseName string, limit int, before *time.Time) ([]store.BackupHistory, error)
}

type DatabaseHealthSource interface {
	DatabaseConnections(ctx context.Context, name string) (used, limit int, err error)
	DatabaseDiskUsedPercent(ctx context.Context, name string) (float64, error)
}

type DatabaseLister interface {
	ListDesiredDatabases(ctx context.Context) ([]store.DesiredDatabase, error)
}

type DatabaseLivenessSource interface {
	DatabaseUp(ctx context.Context, name string) (bool, error)
}

type DatabasePoolerSource interface {
	PoolerSaturation(ctx context.Context, name string) (waiting int, maxWaitSeconds float64, err error)
}

type DefaultRuleSpec struct {
	Key  string
	Rule Rule
}

type DefaultsConfig struct {
	CertExpiryDays []int
	// MonitorsEnabled adds the monitor_down default; the monitor engine is off unless APP_MONITORS_ENABLED is true.
	MonitorsEnabled bool
}

type DeliveryRecorder interface {
	RecordNotificationDelivery(ctx context.Context, d NotificationDelivery) error
}

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

type DeployFailure struct {
	AppName string
	Image   string
	Error   string
	At      time.Time
}

type DeployFailureSource interface {
	RecentDeployFailures(since time.Time) []DeployFailure
}

type DeployLogSource interface {
	QueryDeployLog(ctx context.Context, attemptID string) ([]telemetry.DeployLogEntry, error)
}

type DeployOutcome struct {
	// AppName is the service name; the caller computes the resource ID used for lookup.
	AppName string
	// Image is the tag this attempt deployed or tried to deploy
	// (store.DeployAttempt.Image).
	Image string
	// Succeeded is store.DeployAttempt.Status == succeeded. Never called
	// for the non-terminal "running" status: see Dispatch's own doc
	// comment.
	Succeeded bool
	// Error is store.DeployAttempt.Error: only meaningful, and only ever
	// non-empty, when !Succeeded.
	Error string
	// AttemptID is the deploy attempt, used to read a failed build's output.
	AttemptID string
	// LogLines is the tail of the failing build or container output. The
	// dispatcher fills it for a failed deploy when a log source is set.
	LogLines []string
	// ReleaseNotes is optional markdown for a successful production or
	// promotion deploy. Dispatch clamps it to the configured byte cap.
	ReleaseNotes string
}

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

type DeployTarget struct {
	ID         string
	ResourceID string
	// ChannelID attaches an already-connected NotificationChannel; empty
	// for legacy rows, which use NotifyURL/NotifyKind below directly.
	ChannelID  string
	NotifyURL  string
	NotifyKind NotifyKind
	Enabled    bool
}

type DigestRunner struct {
	DB     *DB
	Sender DigestSender
	Logger *slog.Logger
	Now    func() time.Time
}

type DigestSender interface {
	SendNotice(ctx context.Context, c NotificationChannel, text string) error
}

type DomainCheckSource interface {
	CheckDomainStatus(ctx context.Context, domain string) (status string, err error)
}

type DomainListSource interface {
	ListServiceDomains(ctx context.Context) ([]store.ServiceDomain, error)
}

type DomainTrafficSource interface {
	DomainRequests(ctx context.Context, app, domain string, since, until time.Time) (int, bool)
}

type EmailDeliverySource interface {
	EmailDeliveryStats(ctx context.Context, since time.Time) (store.EmailDeliveryStats, error)
}

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

type Event struct {
	Rule Rule
	// Resolved events are sent too, so operators do not learn to mute a channel that only reports problems starting.
	Resolved bool
	// LogLines is populated only for a firing (not resolved) crashloop
	// event: the last up-to-200 lines of the failing container's logs.
	// Nil for threshold rules and for resolved events.
	LogLines []string
	// CertNotices is set only on a firing cert_expiry event.
	CertNotices []string
	// CertFacts and CertBaseURL drive the actionable cert expiry email; the base URL is empty when no public address is configured.
	CertFacts   []CertFact
	CertBaseURL string
	// PatchNotices is set only on a firing patch_status event.
	PatchNotices []string
	// DiskSpaceNotices is set only on a firing node_disk_space event.
	DiskSpaceNotices []string
	// NodeOfflineNotices is populated only for a firing node_offline
	// event: one line per offline node, from EvaluateNodeOffline.
	NodeOfflineNotices []string
	// NodeCertNotices is populated only for a firing node_cert_expiring
	// event: one line per node whose agent certificate needs attention.
	NodeCertNotices []string
	// ResourceUsageNotices is set only on a firing node_resource_usage event.
	ResourceUsageNotices []string
	// TaskFailureNotice is set only on a firing scheduled_task_failure event.
	TaskFailureNotice string
	// DomainHealthNotices is set only on a firing domain_health event.
	DomainHealthNotices []string
	// BackupMissingNotice is set only on a firing backup_missing event.
	BackupMissingNotice string
	// VersionSkewNotice is set only on a firing version_skew event.
	VersionSkewNotice string
	// BudgetNotices is populated only for a firing budget_threshold event:
	// one line per budget that crossed a threshold.
	BudgetNotices []string

	// SLONotice is set only for a firing slo_burn event: which burn-rate tier
	// tripped and how much error budget is left.
	SLONotice string

	// LogNotice is set for a firing log_pattern or log_level_rate event: the
	// count or rate that tripped. LogLines then holds the matching samples.
	LogNotice string

	// Changes is what changed on the app shortly before it fired; set for
	// firing app-scoped events only. ChangesLink points at its dashboard page.
	Changes     *changes.Result
	ChangesLink string

	// Headline replaces the default first line for flapping and grouped
	// messages; GroupNotices lists the alerts folded into a grouped one.
	Headline     string
	GroupNotices []string
	GroupCount   int
}

type EventSource interface {
	Events(ctx context.Context) (<-chan docker.Event, <-chan error)
}

type ExportHealth struct {
	Name          string
	Enabled       bool
	CreatedAt     time.Time
	LastSuccessAt time.Time
	LastError     string
	CircuitOpen   bool
}

type ExportHealthSource interface {
	ExportHealth(ctx context.Context) ([]ExportHealth, error)
}

type HistoryEntry struct {
	ID         string
	At         time.Time
	RuleID     string
	RuleName   string
	RuleKind   string
	ResourceID string
	App        string
	Node       string
	Severity   string
	Event      string
	Outcome    string
	Detail     string
	SilenceID  string
	ChannelID  string
	Error      string
	// Cert is set on cert_expiry entries; older rows have none.
	Cert *CertPayload
}

type HistoryFilter struct {
	App     string
	RuleID  string
	Outcome string
	Event   string
	Since   time.Time
	Before  *time.Time
	Limit   int
}

type InboxFilter struct {
	UnreadOnly bool
	Archived   bool
	Before     *time.Time
	Limit      int
}

type InboxItem struct {
	HistoryEntry
	Read     bool
	Resolved bool
}

type InboxPrefs struct {
	Principal       string
	MinSeverity     string
	MutedApps       []string
	DigestEnabled   bool
	DigestHour      int
	DigestChannelID string
	LastDigestAt    time.Time
}

type InboxSelector struct {
	Scope     string
	OlderThan time.Duration
	Now       time.Time
}

type InboxState struct {
	ReadIDs     []string
	ArchivedIDs []string
}

type Kind string

type LogArchiveHealth struct {
	// Scope is the app name, or empty for the global policy.
	Scope         string
	Enabled       bool
	Interval      time.Duration
	CreatedAt     time.Time
	LastSuccessAt time.Time
	LastError     string
}

type LogArchiveSource interface {
	LogArchiveHealth(ctx context.Context) ([]LogArchiveHealth, error)
}

type LogRuleConfig struct {
	// Query is a full-text phrase matched by the store's FTS index.
	Query string `json:"query,omitempty"`
	// Regex further narrows the lines by their message (RE2 syntax).
	Regex string `json:"regex,omitempty"`
	// Fields are key=value, key!=value, key~text or key>number filters.
	Fields []string `json:"fields,omitempty"`
	// Level keeps lines at or above it. log_level_rate defaults to error.
	Level string `json:"level,omitempty"`
	// Count is the match count that fires a log_pattern rule.
	Count int `json:"count,omitempty"`
	// PerMinute is the lines per minute that fires a log_level_rate rule.
	PerMinute float64 `json:"per_minute,omitempty"`
	// WindowSeconds is the look-back; zero means five minutes.
	WindowSeconds int `json:"window_seconds,omitempty"`
	// CooldownSeconds suppresses a new firing for this long after the last one.
	CooldownSeconds int `json:"cooldown_seconds,omitempty"`
}

type LogRulePolicy struct {
	EvalEvery time.Duration
	MaxWindow time.Duration
	MaxRows   int
	Samples   int
}

type LogRuleResult struct {
	Matched   int
	Value     float64
	Truncated bool
	Samples   []string
	Notice    string
	Satisfied bool
}

type LogRuleSource interface {
	QueryLogs(ctx context.Context, resourceID string, from, to time.Time, query string) ([]telemetry.LogEntry, error)
}

type LogsSource interface {
	QueryLogs(ctx context.Context, resourceID string, from, to time.Time, query string) ([]telemetry.LogEntry, error)
}

type MailRenderFunc func(ctx context.Context, key, to string, values map[string]string) (email.Message, bool)

type MaintenanceWindow struct {
	ID        string
	Name      string
	Cron      string
	Duration  time.Duration
	Timezone  string
	Scope     string
	Targets   []string
	Enabled   bool
	CreatedBy string
	CreatedAt time.Time
	UpdatedAt time.Time
}

type MetricClass string

type MetricsSource interface {
	QueryMetrics(ctx context.Context, resourceID, metric string, from, to time.Time) ([]telemetry.Sample, error)
}

type MonitorDown struct {
	MonitorID string
	Name      string
	Reason    string
	Since     time.Time
}

type MonitorDownSource interface {
	MonitorsDown() []MonitorDown
}

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

type MuteHit struct {
	ID     string
	Detail string
	Window bool
}

type NodeAlertState string

type NodeAlertStatus struct {
	PatchStatus       NodeAlertState
	NodeDiskSpace     NodeAlertState
	NodeResourceUsage NodeAlertState
}

type NodeCertState string

type NodeServiceSource interface {
	ListDesiredServicesByNode(ctx context.Context, nodeID string) ([]store.DesiredService, error)
}

type NodeSource interface {
	ListNodes(ctx context.Context) ([]store.Node, error)
}

type NoiseConfig struct {
	ConsecutiveFailures int
	FlapThreshold       int
	FlapWindow          time.Duration
	GroupWindow         time.Duration
	RateLimit           int
	RateWindow          time.Duration
	HistoryRetention    time.Duration
	// HistoryRetentionFn, when set, supplies the live retention (0 keeps everything) instead of HistoryRetention.
	HistoryRetentionFn func(ctx context.Context) time.Duration
}

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

type NoiseStore interface {
	ListActiveSilences(ctx context.Context, now time.Time) ([]Silence, error)
	ListMaintenanceWindows(ctx context.Context) ([]MaintenanceWindow, error)
	RecordHistory(ctx context.Context, e HistoryEntry) error
	PruneHistory(ctx context.Context, cutoff time.Time) (int64, error)
}

type NotificationChannel struct {
	ID        string
	Name      string
	Kind      NotifyKind
	NotifyURL string
	Enabled   bool
	// Off by default: it needs InteractiveSecret and a real Slack app or Discord application, not just a webhook URL.
	InteractiveApprovals bool
	// Verifies inbound button clicks came from this channel's app: a Slack signing secret or a Discord Ed25519 public key.
	InteractiveSecret string
	// NotifyDeviceLogin opts this channel into a link-only notice when a CLI
	// device login awaits approval. The notice never carries the code.
	NotifyDeviceLogin bool
	// NotifyDeviceLoginExpired opts this channel into a link-only notice when
	// a pending CLI login lapses unapproved.
	NotifyDeviceLoginExpired bool
	CreatedAt                string
	UpdatedAt                string
}

type NotificationDelivery struct {
	ID        string
	ChannelID string
	Trigger   string
	Success   bool
	Error     string
	CreatedAt string
}

type Notifier interface {
	Notify(ctx context.Context, ev Event) error
}

type NotifyKind string

type ParkedDomainSource interface {
	ListParkedDomains(ctx context.Context) ([]store.ParkedDomain, error)
}

type PlacementSource interface {
	GetDesiredService(ctx context.Context, name string) (*store.DesiredService, error)
	ListNodes(ctx context.Context) ([]store.Node, error)
}

type PluginNotice struct {
	ID         string
	Title      string
	Body       string
	Status     string
	Severity   string
	ResourceID string
	At         time.Time
	// LogLines are log excerpts the plugin runtime releases only to plugins
	// approved for read:sensitive.
	LogLines []string
}

type PluginSender interface {
	SendPlugin(ctx context.Context, plugin, secret string, n PluginNotice) error
}

type PushSender interface {
	Send(ctx context.Context, title, body string) error
}

type QuietHours struct {
	ChannelID string
	Start     string
	End       string
	Timezone  string
	Enabled   bool
}

type RegistryRefreshHealth struct {
	Name      string
	Preset    string
	LastError string
	ExpiresAt *time.Time
}

type RegistryRefreshSource interface {
	RegistryRefreshHealth(ctx context.Context) ([]RegistryRefreshHealth, error)
}

type RequestCounts struct {
	Total float64
	Bad   float64
}

type RestartRecorder interface {
	RecordContainerRestart(ctx context.Context, serviceName string, at time.Time) error
}

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

type RestoreDrillProblem struct {
	Resource string
	Reason   string
	At       time.Time
}

type RestoreDrillSource interface {
	RestoreDrillProblems(ctx context.Context) ([]RestoreDrillProblem, error)
}

type Rule struct {
	ID         string
	Name       string
	Kind       Kind
	ResourceID string

	// Threshold-kind fields.
	Metric      string
	Comparator  Comparator
	Threshold   float64
	ForDuration time.Duration

	// RestartCountThreshold also means consecutive failed runs for KindScheduledTaskFailure, where RestartWindow is unused.
	RestartCountThreshold int
	RestartWindow         time.Duration

	// ScheduledTaskID is the KindScheduledTaskFailure-only field: which
	// of ResourceID's app's scheduled tasks this rule watches. Empty for
	// every other kind.
	ScheduledTaskID string

	// Backup* fields pick the schedule a KindBackupMissing rule watches. ForDuration is the grace period past the expected interval.
	BackupResourceKind string
	BackupDatabaseName string
	BackupServiceName  string
	BackupVolumeName   string

	// ChannelID attaches an already-connected NotificationChannel; empty
	// for legacy rules, which use NotifyURL/NotifyKind below directly.
	// SLO is the KindSLOBurn-only request-based SLO; nil for every other kind.
	SLO *SLOConfig
	// LogRule is the KindLogPattern/KindLogLevelRate-only match config; nil for every other kind.
	LogRule *LogRuleConfig

	ChannelID  string
	NotifyURL  string
	NotifyKind NotifyKind

	// Enabled reflects both this rule's own flag and, once resolved by a
	// read (GetRule/ListRules*), its attached channel's: a disabled
	// channel silences the rule too.
	Enabled bool

	// Noise control: Severity and Labels feed silence matchers;
	// ConsecutiveFailures, FlapThreshold and FlapWindow override the
	// control plane defaults when non-zero.
	Severity            string
	Labels              map[string]string
	ConsecutiveFailures int
	FlapThreshold       int
	FlapWindow          time.Duration

	// Evaluation state, read-only from a caller's perspective: only the
	// evaluator (evaluate.go, crashloop.go) writes these, via
	// UpdateState below.
	PendingSince    *time.Time
	Firing          bool
	FiringSince     *time.Time
	LastEvaluatedAt *time.Time
	LastValue       *float64
}

type RuleStore interface {
	ListEnabledRules(ctx context.Context) ([]Rule, error)
	UpdateState(ctx context.Context, id string, pendingSince, firingSince *time.Time, firing bool, evaluatedAt time.Time, value *float64) error
	RecordNotificationDelivery(ctx context.Context, d NotificationDelivery) error
	UpsertCertExpiryObservation(ctx context.Context, o CertExpiryObservation) error
	ListCertExpiryObservations(ctx context.Context, ruleID string) ([]CertExpiryObservation, error)
}

type SLOAutoRollbackStore interface {
	AutoRollbackStore
	SaveDeployApproval(ctx context.Context, a store.DeployApproval) error
}

type SLOBurnHistoryRecorder interface {
	RecordHistory(ctx context.Context, e HistoryEntry) error
}

type SLOConfig struct {
	Objective string  `json:"objective"`
	Target    float64 `json:"target"`
	LatencyMs float64 `json:"latency_ms,omitempty"`
}

type SLOPolicy struct {
	Tiers       []BurnTier
	Window      time.Duration
	MinRequests float64
	EvalEvery   time.Duration
}

type SLOStatus struct {
	Config          SLOConfig        `json:"config"`
	HasTraffic      bool             `json:"has_traffic"`
	BudgetRemaining float64          `json:"budget_remaining"`
	BudgetRequests  float64          `json:"budget_window_requests"`
	Windows         []BurnWindowStat `json:"windows"`
	Tiers           []TierStatus     `json:"tiers"`
	Firing          bool             `json:"firing"`
	Page            bool             `json:"page"`
	MaxBurn         float64          `json:"max_burn"`
}

type ScheduledTaskSource interface {
	GetScheduledTask(ctx context.Context, id string) (store.ScheduledTask, error)
}

type SendFunc func(ctx context.Context, ev Event) error

type ServiceLister interface {
	ListDesiredServices(ctx context.Context) ([]store.DesiredService, error)
}

type Silence struct {
	ID        string
	Matchers  SilenceMatcher
	StartsAt  time.Time
	EndsAt    time.Time
	CreatedBy string
	Reason    string
	CreatedAt time.Time
	ExpiredAt *time.Time
}

type SilenceMatcher struct {
	RuleIDs    []string          `json:"rule_ids,omitempty"`
	Kinds      []string          `json:"kinds,omitempty"`
	Apps       []string          `json:"apps,omitempty"`
	Nodes      []string          `json:"nodes,omitempty"`
	Labels     map[string]string `json:"labels,omitempty"`
	Severities []string          `json:"severities,omitempty"`
	// Metrics narrows rules that carry a metric (threshold rules); rules without one are not constrained by it.
	Metrics []string `json:"metrics,omitempty"`
}

type SpendCapSource interface {
	SpendCapBreaches(ctx context.Context) ([]spendcap.Breach, error)
}

type TemplatedSender struct {
	email.Sender
	Render MailRenderFunc
}

type TidyConfig struct {
	ArchiveResolvedAfter time.Duration
	Retention            time.Duration
	Interval             time.Duration
}

type TidyResult struct {
	Archived int
	Pruned   int
}

type TidyRunner struct {
	DB     *DB
	Cfg    TidyConfig
	Logger *slog.Logger
	Now    func() time.Time
}

type TierStatus struct {
	BurnTier
	LongBurn  float64 `json:"long_burn"`
	ShortBurn float64 `json:"short_burn"`
	Effective float64 `json:"effective_burn"`
	Firing    bool    `json:"firing"`
}

type VersionSkewSettingsSource interface {
	GetUpdateSettings(ctx context.Context) (store.UpdateSettings, error)
}

type WindowState struct {
	Active    bool
	Start     time.Time
	End       time.Time
	NextStart time.Time
}