@arcfusionz/arc-analytic-ui 0.0.0

package/dist/components/StatusCard/StatusCard.model.d.ts

@@ -0,0 +1,555 @@
+import { ArcTimeGranularity } from "../../lib/vega/formatters.js";
+import { ChartTokens } from "../../lib/vega/tokens.js";
+//#region src/components/StatusCard/StatusCard.model.d.ts
+/** What the consumer's transport reports. */
+type StatusCardStatus = "loading" | "ready" | "error";
+/**
+ * What the card actually shows, derived from `status`, the level, the history
+ * and `filtered`. Stamped on the root as `data-state`. `insufficient` is a
+ * known level with no history to put it in context: there is a state to
+ * report but no run to draw, so the strip's place carries a caption rather
+ * than a one-cell timeline pretending to be a history.
+ */
+type StatusCardState = "loading" | "refreshing" | "ready" | "insufficient" | "empty" | "no-match" | "error";
+/**
+ * The state a monitored thing can be in. Ordered by severity for the strip's
+ * bucket rule (see `STATUS_SEVERITY`), with the two levels that sit outside
+ * the good/bad ladder last: `maintenance` is planned work and `unknown` is
+ * time nobody was watching. The five map onto every status model in the
+ * ecosystem — Statuspage's operational / degraded_performance / partial or
+ * major outage / under_maintenance, Grafana's OK / Pending / Alerting / No
+ * Data, Datadog's OK / Warn / Alert / No Data, Cloudscape's success / warning
+ * / error / pending. Rename them for the product through `labels.levelNames`.
+ */
+type StatusLevel = "operational" | "degraded" | "down" | "maintenance" | "unknown";
+/** Every level in ladder order — the order the key row and the table use. */
+declare const STATUS_LEVELS: readonly StatusLevel[];
+/**
+ * How bad each level is. A strip cell takes the WORST level it overlaps, so
+ * an outage can never be averaged away by the operational time around it; a
+ * gap in monitoring outranks planned work, because "we don't know" is worse
+ * news than "we took it down on purpose".
+ */
+declare const STATUS_SEVERITY: Record<StatusLevel, number>;
+type StatusCardSize = "sm" | "md" | "lg";
+/**
+ * What the big thing is: `level` (default) — the current state as a word, the
+ * answer an operational reader scans for; or `uptime` — the availability
+ * percentage, for an SLA tile whose subject is the number. Stamped as
+ * `data-headline`.
+ */
+type StatusHeadline = "level" | "uptime";
+/**
+ * How the strip divides the window. `auto` (default) buckets it to the finest
+ * step whose cells the measured frame can still render — so no incident is
+ * ever a sub-pixel sliver that disappears — and each cell takes the worst
+ * level inside it. `exact` draws the true state segments, durations
+ * proportional, which is honest on a wide frame and lossy on a narrow one.
+ * The named steps force a granularity. Every figure the card reports is
+ * computed from the exact segments whatever this says; only the drawing
+ * changes. Stamped as `data-resolution`.
+ */
+type StatusResolution = "auto" | "exact" | "minute" | "hour" | "day" | "week";
+/** Whether the availability target was reached over the window. Stamped as `data-verdict`. */
+type StatusVerdict = "met" | "missed";
+/** How availability reads against its target. Stamped as `data-polarity`. */
+type StatusPolarity = "positive" | "negative" | "neutral";
+/**
+ * What availability is a share OF. `monitored` (default) excludes planned
+ * maintenance and unmonitored time from the denominator — the industry
+ * convention, and the only honest one when a window is partly unwatched —
+ * and the card reports how much it excluded. `window` divides by the whole
+ * window, so maintenance and gaps count against the number.
+ */
+type StatusUptimeMode = "monitored" | "window";
+/**
+ * One reported state. `start` is when it began; `end` when it ended — omit it
+ * for the state that is still running and it runs to the window's end. A
+ * date-only ISO string (`"2026-09-10"`) is that calendar day's midnight in the
+ * card's `timeZone`; anything else is an exact instant. `label` names what
+ * happened (`Database failover`) for the tooltip, the incident table and the
+ * descriptions.
+ */
+interface StatusPeriod {
+  level: StatusLevel;
+  start: Date | string | number;
+  end?: Date | string | number | null;
+  label?: string;
+}
+/** A reported state after normalisation: resolved, clipped to the window, contiguous with its neighbours. */
+interface StatusSegment {
+  level: StatusLevel;
+  /** Instants, `end` exclusive. */
+  start: number;
+  end: number;
+  duration: number;
+  label?: string;
+  /** The segment was invented to cover a hole in the history — nobody was watching. */
+  gap?: boolean;
+}
+/** A maximal run of `degraded` / `down` time: what a reader counts as "something happened". */
+interface StatusIncident {
+  start: number;
+  end: number;
+  duration: number;
+  /** The worst level reached inside the run. */
+  level: "degraded" | "down";
+  /** How much of the run was fully down. */
+  downtime: number;
+  label?: string;
+}
+/** Availability against a target, and the error budget that leaves. */
+interface StatusSla {
+  /** The target as a ratio (`0.999`). */
+  target: number;
+  verdict: StatusVerdict;
+  /** Unavailable time the target allows over the denominator. */
+  allowed: number;
+  /** Unavailable time actually spent. */
+  used: number;
+  /** `allowed - used`, floored at zero. */
+  remaining: number;
+  /** How much of the budget is gone, as a ratio — may exceed 1. */
+  consumed: number;
+}
+interface StatusWindow {
+  start: number;
+  end: number;
+  span: number;
+}
+/** Everything the card reports, all of it measured on the exact segments. */
+interface StatusRun {
+  window: StatusWindow;
+  /** The run, contiguous across the whole window. */
+  segments: StatusSegment[];
+  /** Milliseconds spent at each level. */
+  durations: Record<StatusLevel, number>;
+  /** The state as of the window's end. */
+  level: StatusLevel;
+  /** When the current state began — the start of the last unbroken run at `level`. */
+  since: number;
+  /** How long it has held, to the window's end. */
+  sinceDuration: number;
+  /** The state was already running when the window opened, so `sinceDuration` is a floor, not the true age. */
+  sinceClipped: boolean;
+  /** The worst level anywhere in the window. */
+  worst: StatusLevel;
+  incidents: StatusIncident[];
+  /** The longest incident, for the details table. */
+  longestIncident: StatusIncident | null;
+  /** Time fully down. */
+  downtime: number;
+  /** Time excluded from the denominator (maintenance and unmonitored), under `monitored`. */
+  excluded: number;
+  /** The denominator availability is a share of. */
+  monitored: number;
+  /** Operational share of `monitored`, or `null` when there is nothing to divide by. */
+  uptime: number | null;
+  mode: StatusUptimeMode;
+  sla: StatusSla | null;
+  polarity: StatusPolarity;
+}
+interface DeriveStatusStateInput {
+  status: StatusCardStatus;
+  /** A current level is known — reported or read off the history. */
+  hasLevel: boolean;
+  /** A run exists to draw. */
+  hasHistory: boolean;
+  /** Anything is on screen already, so a reload is a refresh rather than a first load. */
+  hasData: boolean;
+  filtered: boolean;
+}
+/**
+ * The state machine. Error wins; loading over existing data is a refresh (the
+ * previous render stays under the veil); a missing level is `no-match` when
+ * the consumer's filter caused it and `empty` otherwise; a level with no run
+ * behind it is `insufficient` — the card reports the state and says it has no
+ * history rather than drawing a single cell as if it were one.
+ */
+declare function deriveStatusState({ status, hasLevel, hasHistory, hasData, filtered }: DeriveStatusStateInput): StatusCardState;
+interface StatusWindowInput {
+  start: Date | string | number;
+  end: Date | string | number;
+}
+/**
+ * The strip's domain. An explicit `window` wins; otherwise it spans the
+ * history — from the first reported start to the last reported end, extended
+ * to `asOf` when the card knows when it was last true, so a still-running
+ * state reaches the right-hand edge. `null` when there is nothing to span or
+ * the bounds have no length.
+ */
+declare function resolveStatusWindow(window: StatusWindowInput | undefined, history: readonly StatusPeriod[] | undefined, asOf: number | null, timeZone?: string): StatusWindow | null;
+/**
+ * The reported states as one contiguous run across the window: resolved to
+ * instants, sorted, clipped to the window, implicit ends closed by the next
+ * start, overlaps resolved in favour of the later report (a correction
+ * supersedes what it corrects), holes filled with explicit `unknown` segments
+ * — a gap in monitoring is a fact, not a blank — and neighbours at the same
+ * level merged so the run reads as states rather than as reports.
+ */
+declare function normalizeHistory(history: readonly StatusPeriod[] | undefined, window: StatusWindow, timeZone?: string): StatusSegment[];
+/** The `degraded` / `down` runs inside a normalised run. */
+declare function deriveIncidents(segments: readonly StatusSegment[]): StatusIncident[];
+interface DeriveStatusRunInput {
+  level?: StatusLevel | null;
+  since?: Date | string | number | null;
+  history?: readonly StatusPeriod[];
+  window?: StatusWindowInput;
+  /** When the data was last true — the run's right-hand edge when no window is given. */
+  asOf?: number | null;
+  uptimeTarget?: number | null;
+  mode?: StatusUptimeMode;
+  timeZone?: string;
+}
+/**
+ * Everything the card reports, measured on the exact segments — never on the
+ * strip's cells, so the figures stay true however coarsely the strip has to
+ * draw. `null` when there is no window to measure over.
+ *
+ * A reported `level` is the current state, appended to the history as a
+ * still-running period: from `since` when the consumer knows when it began,
+ * otherwise from wherever the history stops — so the strip's right-hand edge
+ * always agrees with the word in the headline instead of contradicting it.
+ * With no `level` at all, the current state is read off the end of the run.
+ */
+declare function deriveStatusRun({ level, since, history, window, asOf, uptimeTarget, mode, timeZone }: DeriveStatusRunInput): StatusRun | null;
+/** How long the current state has held, and whether that is its true age. */
+interface StatusHold {
+  since: number;
+  duration: number;
+  /** The state was already running when the window opened — the duration is a floor. */
+  atLeast: boolean;
+}
+/**
+ * The current state's age. From the run when there is one; from `since`
+ * against `asOf` when the card has a level but no window to draw (the
+ * `insufficient` state still owes the reader "how long"). `null` when nothing
+ * pins the moment it began.
+ */
+declare function resolveStatusHold({ run, since, asOf, timeZone }: {
+  run: StatusRun | null;
+  since?: Date | string | number | null;
+  asOf: number | null;
+  timeZone?: string;
+}): StatusHold | null;
+/** One cell the strip draws — a bucket, or an exact segment. */
+interface StatusStripRow {
+  /** Instants; already inset by the gap that keeps touching fills apart. */
+  start: number;
+  end: number;
+  /** The cell's true bounds, for the tooltip and the description. */
+  from: number;
+  to: number;
+  /** The worst level the cell covers — what it is painted. */
+  level: StatusLevel;
+  /** The paintable hue, carried in the row so a level change is a data push that cannot repaint its neighbours. */
+  c: string;
+  /** True milliseconds at each level inside the cell, for the tooltip. */
+  durations: Record<StatusLevel, number>;
+  /** The first event name the cell covers. */
+  label?: string;
+}
+interface StatusStrip {
+  rows: StatusStripRow[];
+  /** The bucket width in milliseconds, or `null` when the rows are exact segments. */
+  step: number | null;
+  /** The granularity dates read at in the cell tooltip. */
+  granularity: ArcTimeGranularity;
+  /** The granularity the x-axis labels read at. */
+  axisGranularity: ArcTimeGranularity;
+}
+/** The hue a level paints with, from the theme's status ladder. */
+declare function statusHue(tokens: ChartTokens, level: StatusLevel): string;
+/** The resolved granularity as a word — the value of `data-resolution`. */
+declare function statusStepKey(step: number | null): string;
+interface BuildStatusStripInput {
+  run: StatusRun;
+  resolution: StatusResolution;
+  tokens: ChartTokens;
+  /** The plot's measured width in pixels — what decides how fine `auto` can go. */
+  plotWidth: number;
+  /** The narrowest cell that still reads as a block. */
+  minCellPx: number;
+  /** The gap between touching cells, as a share of the cell pitch. */
+  gapRatio: number;
+  /** …clamped to this many pixels at each end, so a wide cell keeps its gap modest and a narrow one keeps its fill. */
+  gapMinPx: number;
+  gapMaxPx: number;
+  timeZone?: string;
+}
+/**
+ * The rows the strip draws. `exact` emits the true segments; every other
+ * resolution divides the window into equal cells, each painted the worst
+ * level it overlaps — the Statuspage rule, and the only way a 40-second
+ * outage in a 90-day window is visible at all. `auto` takes the finest step
+ * from the ladder whose cells still clear `minCellPx` at the measured width,
+ * so a narrow tile degrades to coarser cells instead of to sub-pixel slivers.
+ *
+ * Cells are inset by a share of their own pitch so touching fills stay apart
+ * without a stroke eating a narrow cell, and each row keeps its true bounds
+ * and its true per-level durations for the tooltip — the drawing rounds, the
+ * numbers never do.
+ */
+declare function buildStatusStrip({ run, resolution, tokens, plotWidth, minCellPx, gapRatio, gapMinPx, gapMaxPx, timeZone }: BuildStatusStripInput): StatusStrip;
+/** The bucket width, or `null` for exact segments. Exported for the unit tests. */
+declare function resolveStep(resolution: StatusResolution, span: number, plotWidth: number, minCellPx: number): number | null;
+interface StatusDurationUnits {
+  day: string;
+  hour: string;
+  minute: string;
+  second: string;
+}
+interface FormatDurationOptions {
+  units: StatusDurationUnits;
+  locale?: string;
+  /** How many units the text carries. Default 2 — `6d 4h`, never `6d 4h 12m 3s`. */
+  maxUnits?: number;
+  /** Rendered for a zero duration. */
+  zero: string;
+}
+/**
+ * A duration in the two most significant units it has — `6d 4h`, `2h 14m`,
+ * `41m`, `18s`. Precision to the decision (Few's pitfall #3): nobody pages
+ * anyone over the seconds of a six-day uptime. Units come from `labels` so a
+ * Thai product reads in Thai; `Intl.DurationFormat` is deliberately not used
+ * — it is too new to rely on across the runtimes this package supports.
+ */
+declare function formatDuration(ms: number | null | undefined, { units, locale, maxUnits, zero }: FormatDurationOptions): string;
+interface StatusTextFormatters {
+  /** Availability as a percentage, in the card's `uptimeFormat`. */
+  formatUptime: (value: number | null | undefined) => string;
+  /** A duration in words. */
+  formatDuration: (ms: number | null | undefined) => string;
+  /** An instant at a granularity. */
+  formatInstant: (instant: number | null | undefined, granularity?: ArcTimeGranularity) => string;
+  /** A cell's or an incident's span. */
+  formatSpan: (from: number, to: number, granularity?: ArcTimeGranularity) => string;
+}
+interface CreateStatusFormattersInput {
+  uptimeFormat: string;
+  formatUptimeValue?: (value: number) => string;
+  units: StatusDurationUnits;
+  zeroDuration: string;
+  locale?: string;
+  timeZone?: string;
+}
+/** One grammar for every surface, so the same duration or share never reads two ways. */
+declare function createStatusFormatters({ uptimeFormat, formatUptimeValue, units, zeroDuration, locale, timeZone }: CreateStatusFormattersInput): StatusTextFormatters;
+interface StatusCardLabels {
+  /** The five levels as the product names them. */
+  levelNames: Record<StatusLevel, string>;
+  /** How long the current state has held — `for 6d 4h`. */
+  heldFor: (duration: string) => string;
+  /** The chip when the current state began outside the window, so its true age is unknown. */
+  heldAtLeast: (duration: string) => string;
+  /** After the availability number in the badge's comparison line, with no target — `uptime · 30d`. */
+  uptimeOver: (span: string) => string;
+  /**
+   * … and with one. The verdict and the target it is against share ONE line —
+   * `99.50% target met` — rather than a chip above a `vs 99.50% target`
+   * caption: two rows to say one thing is what made the tile read as clutter.
+   * Kept short enough to stay on one line in a wallboard column, which is why
+   * the error budget is not appended here — it is a figure a reader looks up,
+   * and it has three homes already (the badge's own tooltip, the details
+   * table and the generated description).
+   */
+  vsTarget: (target: string, met: boolean) => string;
+  /** The availability figure's name in the table and the descriptions. */
+  uptime: string;
+  /** The denominator's name — availability is a share of monitored time by default. */
+  monitored: string;
+  /** The window's name. */
+  window: string;
+  /** The incident count in the strip's caption — `2 incidents`, `1 incident`. `count` is already formatted for the locale; `n` is the number, for languages that inflect. */
+  incidents: (count: string, n: number) => string;
+  /** The time fully down on the figures line — `41m down`. */
+  downFor: (duration: string) => string;
+  /** The error budget still unspent — `2m budget left`. */
+  budgetLeft: (duration: string) => string;
+  /** … and the overspend once it is gone — `18m over budget`. */
+  budgetOver: (duration: string) => string;
+  /** The table row naming the current state. */
+  currentRow: string;
+  sinceRow: string;
+  durationRow: string;
+  worstRow: string;
+  incidentsRow: string;
+  longestIncidentRow: string;
+  downtimeRow: string;
+  excludedRow: string;
+  targetRow: string;
+  budgetRow: string;
+  /** The table row naming what the strip's cells mean. */
+  stripRow: string;
+  /** The strip's granularity, declared — `worst status per day`. */
+  resolutionNote: (step: string) => string;
+  /** … and when the strip draws true segments instead of buckets. */
+  exactNote: string;
+  /** The verdicts as words. */
+  verdictNames: Record<StatusVerdict, string>;
+  /** Column headers for the summary table. */
+  tableItem: string;
+  tableValue: string;
+  /** Column headers for the incident table. */
+  incidentTableWhen: string;
+  incidentTableLevel: string;
+  incidentTableFor: string;
+  /** Caption over the incident table. */
+  incidentTableCaption: (name: string) => string;
+  /** The caption's centre when the window had none, and the incident table's own empty line. Kept short: the window's dates flank it on both sides. */
+  noIncidents: string;
+  /** Duration units, shortest form — a duration is scanned, not read. */
+  durationUnits: StatusDurationUnits;
+  /** Rendered for a zero duration. */
+  zeroDuration: string;
+  noData: string;
+  noMatch: string;
+  clearFilters: string;
+  error: string;
+  retry: string;
+  /** Caption in the strip's place when a level is known but no history is. */
+  noHistory: string;
+  stale: string;
+  asOf: string;
+  showTable: (name: string) => string;
+  hideTable: (name: string) => string;
+  about: (name: string) => string;
+  loading: (name: string) => string;
+  tableCaption: (name: string) => string;
+  /** Accessible name of the focusable availability group. */
+  uptimeGroup: (name: string) => string;
+  /** Accessible name of the current-state announcement. */
+  levelGroup: (name: string) => string;
+  insightMark: string;
+  /** The rows behind the availability badge, on hover and through `aria-describedby`. */
+  explanation: (input: StatusExplanationInput) => (readonly [string, string])[];
+  /** Sentences the card's own description is assembled from. */
+  levelSentence: (input: {
+    name: string;
+    level: string;
+    duration: string;
+    atLeast: boolean;
+  }) => string;
+  uptimeSentence: (input: {
+    uptime: string;
+    span: string;
+    monitored: string;
+    mode: StatusUptimeMode;
+  }) => string;
+  incidentSentence: (input: {
+    count: number;
+    countText: string;
+    downtime: string;
+    longest: string | null;
+  }) => string;
+  slaSentence: (input: {
+    target: string;
+    met: boolean;
+    remaining: string;
+    over: boolean;
+  }) => string;
+  windowSentence: (input: {
+    range: string;
+  }) => string;
+  /** The strip's own `aria-label`. */
+  chartDescription: (input: StatusChartDescriptionInput) => string;
+}
+interface StatusExplanationInput {
+  uptimeText: string;
+  spanText: string;
+  monitoredText: string;
+  mode: StatusUptimeMode;
+  excludedText: string | null;
+  downtimeText: string;
+  incidentsText: string;
+  sla: {
+    targetText: string;
+    verdictText: string;
+    remainingText: string;
+    over: boolean;
+  } | null;
+}
+interface StatusChartDescriptionInput {
+  name: string;
+  rangeText: string;
+  resolutionText: string;
+  levels: (readonly [string, string])[];
+  incidents: string;
+}
+declare const DEFAULT_STATUS_LABELS: StatusCardLabels;
+declare function resolveStatusLabels(overrides?: Partial<StatusCardLabels>): StatusCardLabels;
+/** The levels present in the window, in ladder order, with their durations — the key row, the table and the descriptions all read from this. */
+declare function statusLevelBreakdown(run: StatusRun, formatters: StatusTextFormatters, labels: StatusCardLabels): {
+  level: StatusLevel;
+  name: string;
+  duration: number;
+  durationText: string;
+}[];
+/**
+ * A strip cell's span as the tooltip states it. A bucket's `end` is EXCLUSIVE,
+ * so at day granularity a single-day cell would read "Sep 2 – 3, 2026" — two
+ * days for one cell. Closing the range on the last instant the cell actually
+ * covers collapses it to "Sep 2, 2026" and turns a three-day cell into
+ * "Jun 12 – 14, 2026". Sub-day cells keep the exclusive bound, where
+ * "12:00 AM – 12:00 PM" reads better than "12:00 AM – 11:59 AM".
+ */
+declare function formatStripCell(row: Pick<StatusStripRow, "from" | "to">, strip: Pick<StatusStrip, "granularity" | "step">, formatters: StatusTextFormatters): string;
+/** How the strip's granularity is stated, in words. */
+declare function describeResolution(strip: StatusStrip, formatters: StatusTextFormatters, labels: StatusCardLabels): string;
+interface BuildStatusExplanationInput {
+  run: StatusRun;
+  formatters: StatusTextFormatters;
+  labels: StatusCardLabels;
+}
+/** The rows behind the availability badge — hover, and `aria-describedby`. */
+declare function buildStatusExplanation({ run, formatters, labels }: BuildStatusExplanationInput): (readonly [string, string])[];
+interface StatusDetailRow {
+  key: string;
+  label: string;
+  value: string;
+  /** Colours the value the way a delta is coloured — only where the figure means good or bad. */
+  tone?: StatusPolarity;
+}
+/** The summary table twin: every figure the card face and its tooltips show. */
+declare function buildStatusDetailRows({ run, strip, formatters, labels }: BuildStatusExplanationInput & {
+  strip: StatusStrip | null;
+}): StatusDetailRow[];
+interface StatusIncidentRow {
+  key: string;
+  when: string;
+  level: StatusLevel;
+  levelName: string;
+  duration: string;
+  label?: string;
+}
+/** The incident table twin — every incident the strip paints, with its true duration. */
+declare function buildStatusIncidentRows({ run, formatters, labels }: BuildStatusExplanationInput): StatusIncidentRow[];
+interface BuildStatusDescriptionInput {
+  name: string;
+  state: StatusCardState;
+  run: StatusRun | null;
+  /** The current state — known in the `insufficient` state too, where there is no run. */
+  level: StatusLevel | null;
+  hold: StatusHold | null;
+  formatters: StatusTextFormatters;
+  labels: StatusCardLabels;
+  asOfText?: string;
+}
+/**
+ * The card's generated accessible description: the state and how long it has
+ * held, availability over the window (and how much of it was monitored), the
+ * incidents and the downtime, the SLA verdict with the budget it leaves, the
+ * window, and when the data was last true — Amy Cesal's alt-text formula
+ * applied to a status tile.
+ */
+declare function buildStatusDescription({ name, state, run, level, hold, formatters, labels, asOfText }: BuildStatusDescriptionInput): string;
+/** The strip's own `aria-label` — chart type, what data, at what granularity, and what it adds up to. */
+declare function buildStatusChartDescription({ name, run, strip, formatters, labels }: {
+  name: string;
+  run: StatusRun;
+  strip: StatusStrip;
+  formatters: StatusTextFormatters;
+  labels: StatusCardLabels;
+}): string;
+//#endregion
+export { BuildStatusDescriptionInput, BuildStatusExplanationInput, BuildStatusStripInput, CreateStatusFormattersInput, DEFAULT_STATUS_LABELS, DeriveStatusRunInput, DeriveStatusStateInput, FormatDurationOptions, STATUS_LEVELS, STATUS_SEVERITY, StatusCardLabels, StatusCardSize, StatusCardState, StatusCardStatus, StatusChartDescriptionInput, StatusDetailRow, StatusDurationUnits, StatusExplanationInput, StatusHeadline, StatusHold, StatusIncident, StatusIncidentRow, StatusLevel, StatusPeriod, StatusPolarity, StatusResolution, StatusRun, StatusSegment, StatusSla, StatusStrip, StatusStripRow, StatusTextFormatters, StatusUptimeMode, StatusVerdict, StatusWindow, StatusWindowInput, buildStatusChartDescription, buildStatusDescription, buildStatusDetailRows, buildStatusExplanation, buildStatusIncidentRows, buildStatusStrip, createStatusFormatters, deriveIncidents, deriveStatusRun, deriveStatusState, describeResolution, formatDuration, formatStripCell, normalizeHistory, resolveStatusHold, resolveStatusLabels, resolveStatusWindow, resolveStep, statusHue, statusLevelBreakdown, statusStepKey };