@letpeoplework/lighthouse-client 1.8.1 → 1.9.0

package/dist/index.d.ts

@@ -1,191 +1,1340 @@
-type ClientCapability = "versioned-api-contracts" | "shared-domain-operations" | "connectivity-and-discovery-contracts" | "automation-auth-contracts";
-type ClientPackageContract = {
-    readonly name: "@letpeoplework/lighthouse-client";
-    readonly capabilities: readonly ClientCapability[];
-};
-declare const getClientPackageContract: () => ClientPackageContract;
-type ConnectivityCategory = "success" | "unreachable" | "misconfigured" | "unauthorized" | "dependency-failure" | "concurrency-conflict" | "unexpected";
-type StandaloneDiscoveryContract = {
-    readonly contractVersion: 1;
-    readonly lighthouseUrl: string;
-    readonly detectedAtUtc: string;
-};
-type StandaloneDiscoveryContractParseResult = {
-    readonly isValid: true;
-    readonly contract: StandaloneDiscoveryContract;
+//#region src/usageData.d.ts
+/** Where a usage event came from, as Lighthouse names it. A client only ever declares its own. */
+export type UsageDataSource = "Browser" | "Cli" | "Mcp";
+export type ClientUsageDataSource = Exclude<UsageDataSource, "Browser">;
+/** The usage events a client reports that carry nothing but their name. */
+export type PlainUsageDataEventName = "TeamCreated" | "TeamDeleted" | "PortfolioCreated" | "PortfolioDeleted" | "TeamManualForecastRun" | "TeamRefreshTriggered" | "PortfolioRefreshTriggered";
+/** The usage events that say when, relative to the Team's Refinement, a vote was cast. */
+export type SizingUsageDataEventName = "TeamSizingVoteCast" | "TeamSizingReadinessReached";
+/** The usage event that says which verdict a Team's Refinement showed on its Refinement day. */
+export type VerdictUsageDataEventName = "TeamRefinementDayVerdictShown";
+/** The usage events a client reports, by the names Lighthouse already counts for the web. */
+export type UsageDataEventName = PlainUsageDataEventName | SizingUsageDataEventName | VerdictUsageDataEventName;
+/** Fewer Work Items ready than needed, enough, more than enough, or no number at all. */
+export type UsageDataRefinementVerdict = "Below" | "In" | "Above" | "None";
+export type UsageDataSizingMoment = "NoCadence" | "OnRefinementDay" | "OnOtherDay";
+/** Something a person did that is worth counting: names and values from closed lists, never free text. */
+export type UsageDataOccurrence = {
+  readonly name: PlainUsageDataEventName;
 } | {
-    readonly isValid: false;
-    readonly reason: string;
+  readonly name: SizingUsageDataEventName;
+  readonly sizingMoment: UsageDataSizingMoment;
+} | {
+  readonly name: VerdictUsageDataEventName;
+  readonly refinementVerdict: UsageDataRefinementVerdict;
+};
+/** What Lighthouse's answer about a Team's Refinement says about today. */
+export type RefinementMomentFacts = {
+  readonly nextRefinementDate: string | null;
+  readonly isRefinementDay: boolean;
+};
+/**
+ * When a vote was cast, from Lighthouse's answer rather than this machine's clock: Lighthouse counts days in
+ * the instance's time zone and knows which cadence days are blacked out. The web counts it the same way.
+ */
+export declare const sizingMomentOf: ({ nextRefinementDate, isRefinementDay }: RefinementMomentFacts) => UsageDataSizingMoment;
+/** What Lighthouse's answer about a Team's Refinement says about today's verdict. */
+export type RefinementDayFacts = {
+  readonly isRefinementDay: boolean;
+  readonly workItemsListed: number;
+  readonly verdict: "Below" | "In" | "Above" | null;
+};
+/**
+ * The verdict worth counting, or null when there is none: only a Refinement day with Work Items listed
+ * counts, since without any the Refinement says so instead of showing a verdict. The web counts it the same way.
+ */
+export declare const refinementDayVerdictOf: ({ isRefinementDay, workItemsListed, verdict }: RefinementDayFacts) => UsageDataRefinementVerdict | null;
+export type UsageDataEvent = UsageDataOccurrence & {
+  readonly offsetMs: number;
+  readonly sequence: number;
 };
-type LighthouseConnectionConfiguration = {
-    readonly kind: "explicit";
-    readonly lighthouseUrl: string;
+export type UsageDataBatch = {
+  readonly source: ClientUsageDataSource;
+  readonly events: readonly UsageDataEvent[];
+};
+/** What Lighthouse says about usage data from this client; `acceptedSources` is null on a server that predates it. */
+export type UsageDataState = {
+  readonly decision: string | null;
+  readonly mayAsk: boolean;
+  readonly administratorDisabled: boolean;
+  readonly acceptedSources: readonly string[] | null;
+};
+/** The answer a person gave for one Lighthouse. */
+export type StoredUsageDataAnswer = {
+  readonly answer: "yes";
+  readonly token: string;
+  readonly confirmedAt: string;
 } | {
-    readonly kind: "standalone";
-    readonly getDiscoveryContract: () => Promise<StandaloneDiscoveryContract | null>;
-};
-type ConnectivityFetchResponse = {
-    readonly ok: boolean;
-    readonly status: number;
-    readonly text: () => Promise<string>;
-    readonly json?: () => Promise<unknown>;
-};
-type ConnectivityDependencies = {
-    readonly fetch: (url: string, init?: RequestInit) => Promise<ConnectivityFetchResponse>;
-};
-type ResolvedLighthouseEndpoint = {
-    readonly mode: "explicit" | "standalone";
-    readonly lighthouseUrl: string;
-    readonly apiBaseUrl: string;
-    readonly healthCheckUrl: string;
-};
-type ConnectivityValidationResult = {
-    readonly category: "success";
-    readonly endpoint: ResolvedLighthouseEndpoint;
-    readonly serverVersion: string;
+  readonly answer: "no";
+  readonly decidedAt: string;
+};
+/** Lighthouse's state answer, or null when it is not one. */
+export declare const readUsageDataState: (json: unknown) => UsageDataState | null;
+/** A stored answer, or null when the value is not one. */
+export declare const readStoredUsageDataAnswer: (value: unknown) => StoredUsageDataAnswer | null;
+/**
+ * `DO_NOT_TRACK` asks every tool to send nothing. Set to anything but empty, `0` or `false` (any case), it is
+ * honoured.
+ */
+export declare const isDoNotTrackSet: (env: Readonly<Record<string, string | undefined>>) => boolean;
+/** Which of a command line's three streams are terminals. */
+export type TerminalStreams = {
+  readonly stdinIsTTY: boolean;
+  readonly stdoutIsTTY: boolean;
+  readonly stderrIsTTY: boolean;
+};
+/**
+ * A question needs a person: one who can type (stdin), sees the answer (stdout) and the question (stderr),
+ * and is not a build agent behind a pseudo-terminal (`CI` set to anything).
+ */
+export declare const isAPersonAtTheTerminal: (streams: TerminalStreams, env: Readonly<Record<string, string | undefined>>) => boolean;
+export type UsageDataStepFacts = {
+  readonly doNotTrack: boolean;
+  /** The answer kept for this Lighthouse: undefined when never asked there. */
+  readonly stored: StoredUsageDataAnswer | undefined | "unreadable";
+  /** Lighthouse's state: not read yet, or could not be read. */
+  readonly state: UsageDataState | "unread" | "unavailable";
+  readonly source: ClientUsageDataSource;
+  /** Whether a person is there to be asked. */
+  readonly mayPrompt: boolean;
+  /** Whether the command reached Lighthouse and succeeded. */
+  readonly reached: boolean;
+  readonly occurrences: readonly UsageDataOccurrence[];
+  readonly now: Date;
+};
+export type UsageDataPlan = {
+  readonly kind: "nothing";
 } | {
-    readonly category: Exclude<ConnectivityCategory, "success">;
-    readonly reason: string;
-    readonly statusCode?: number;
-    readonly endpoint?: ResolvedLighthouseEndpoint;
-};
-declare const parseStandaloneDiscoveryContract: (serializedContract: string) => StandaloneDiscoveryContractParseResult;
-declare const getStandaloneDiscoveryLockfilePath: () => string;
-declare const loadStandaloneDiscoveryContract: () => Promise<StandaloneDiscoveryContract | null>;
-declare const validateLighthouseConnectivity: (configuration: LighthouseConnectionConfiguration, dependencies: ConnectivityDependencies, requestInit?: RequestInit) => Promise<ConnectivityValidationResult>;
-type LighthouseClientAuth = {
-    readonly kind: "none";
+  readonly kind: "read-state";
+  readonly token: string | undefined;
 } | {
-    readonly kind: "api-key";
-    readonly value: string;
-    readonly headerName?: string;
+  readonly kind: "ask";
 } | {
-    readonly kind: "bearer-token";
-    readonly token: string;
+  readonly kind: "send";
+  readonly token: string;
+  readonly batch: UsageDataBatch;
+  /** Lighthouse has just confirmed the grant, so it is kept as confirmed now. */
+  readonly reconfirmed: boolean;
+} | {
+  readonly kind: "re-grant-then-send";
+  readonly formerToken: string;
+  readonly batch: UsageDataBatch;
+};
+/** What to do about usage data after a command, decided from facts alone. */
+export declare const planUsageDataStep: (facts: UsageDataStepFacts) => UsageDataPlan;
+//#endregion
+//#region src/terminology.d.ts
+/** Every word an instance may rename under Settings → Terminology, by its key. */
+export type TerminologyKey = "workItem" | "workItems" | "feature" | "features" | "cycleTime" | "throughput" | "workInProgress" | "wip" | "workItemAge" | "tag" | "workTrackingSystem" | "workTrackingSystems" | "blocked" | "serviceLevelExpectation" | "sle" | "team" | "teams" | "portfolio" | "portfolios" | "delivery" | "deliveries" | "refinement" | "refinements";
+/** The instance's word for every configurable term. */
+export type Terms = Readonly<Record<TerminologyKey, string>>;
+/** The words a new Lighthouse instance starts with, as its seeder writes them. */
+export declare const SEEDED_TERMS: Terms;
+/**
+ * The instance's words, a blank or missing one falling back to its entry's default, then the seeded word, as on
+ * the web. A value that is not text at all falls back the same way, so a view never prints a number or an object
+ * where a word belongs.
+ */
+export declare const resolveTerms: (entries: readonly TerminologyEntry[] | null) => Terms;
+export type TermsSource = Pick<LighthouseClient, "getTerminology">;
+/** The instance's words; when they cannot be read the seeded ones stand in, so this never fails. */
+export declare const readTerms: (source: TermsSource) => Promise<Terms>;
+//#endregion
+//#region src/answerWording.d.ts
+type Read$1 = {
+  readonly ok: true;
+  readonly value: unknown;
+} | {
+  readonly ok: false;
+  readonly error: unknown;
+};
+/** What an answer is said with: the instance's words and the name of what it is about. */
+export type AnswerWording = {
+  readonly terms: Terms;
+  readonly name: string;
+};
+/** What an answer is about: the term for its kind, its id, and the read that names it. */
+export type AnswerSubject = {
+  readonly term: TerminologyKey;
+  readonly id: number;
+  readonly read: () => Promise<Read$1>;
+};
+/** The subject's name, or its term and id when the name cannot be had: "Team [id: 3]". */
+export declare const nameOrFallback: (read: Read$1, subject: Pick<AnswerSubject, "term" | "id">, terms: Terms) => string;
+/**
+ * Reads the instance's words and the subject's name together. Neither read can fail the answer: the
+ * seeded words and the term with the id stand in, because a heading is never worth an error.
+ */
+export declare const readAnswerWording: (source: TermsSource, subject: AnswerSubject) => Promise<AnswerWording>;
+/**
+ * The words for an answer about one Feature, named by its reference and name. The answer itself never
+ * carries the name, so it is read from the Feature.
+ */
+export declare const readFeatureWording: (source: TermsSource & {
+  readonly getFeaturesByIds: (ids: readonly number[]) => Promise<Read$1>;
+}, featureId: number) => Promise<AnswerWording>;
+//#endregion
+//#region src/calendarDates.d.ts
+export declare const isCalendarDay: (value: string | null) => boolean;
+/** "2026-10-30" or "2026-10-30T00:00:00Z" as "Fri 30 Oct 2026", whatever the reader's time zone; null for no such day. */
+export declare const formatCalendarDay: (wire: string) => string | null;
+/** A moment as "Tue 6 Oct 2026, 07:14" on the reader's own clock; null when it is not a moment. */
+export declare const formatTimestamp: (wire: string) => string | null;
+//#endregion
+//#region src/deliveryWording.d.ts
+/** One Delivery as its card's header states it. Facts an older Lighthouse may not send stay undefined. */
+export type DeliveryListItem = {
+  readonly id: number;
+  readonly name: string;
+  readonly date: string;
+  readonly featureCount: number | undefined;
+  readonly totalWork: number;
+  readonly remainingWork: number;
+  readonly likelihood: number | null;
+  readonly cannotBeForecast: boolean;
+  readonly hasSufficientData: boolean | undefined;
+  readonly isOverdue: boolean | undefined;
+  readonly likelyBy: string | undefined;
+};
+/** The Portfolio whose Deliveries are listed; its name stays undefined when it could not be read. */
+export type DeliveryListOwner = {
+  readonly id: number;
+  readonly name: string | undefined;
 };
-type StoredLighthouseAuth = Exclude<LighthouseClientAuth, {
-    kind: "none";
+/**
+ * Every Delivery in the list, or null when the answer is not a list or any one of them comes without its
+ * id, name, date or work: a row that cannot say what it is or when it is due would misstate the list.
+ */
+export declare const readDeliveryList: (value: unknown) => DeliveryListItem[] | null;
+/** "Ocean Explorer · Deliveries", or the Portfolio by its id when its name could not be read. */
+export declare const describeDeliveryListTitle: (owner: DeliveryListOwner, terms: Terms) => string;
+/** What a Portfolio without any Delivery shows instead of the table. */
+export declare const describeNoDeliveries: (terms: Terms) => string;
+/** How many Deliveries the list holds, in the instance's words: "No Deliveries", "1 Delivery", "4 Deliveries". */
+export declare const describeDeliveryCount: (count: number, terms: Terms) => string;
+/** The list's column headings: the card's header facts, its four forecast chances narrowed to the 85% one. */
+export declare const describeDeliveryListHeadings: (terms: Terms) => string[];
+/** How much of the Delivery's work is done: "34 of 55 Work Items". */
+export declare const describeDeliveryDone: (delivery: Pick<DeliveryListItem, "totalWork" | "remainingWork">, terms: Terms) => string;
+/** The card's likelihood answer: "78%", ">95%", "Overdue", "Not enough data", "Cannot forecast". */
+export declare const describeDeliveryLikelihood: (delivery: DeliveryListItem) => string;
+/** One Delivery as a row of the list, in the order of its headings. */
+export declare const describeDeliveryRow: (delivery: DeliveryListItem, terms: Terms) => string[];
+/**
+ * A Delivery's recorded days, or null when the answer lacks its Delivery Date or any day lacks a fact its
+ * row or detail states: a table with a hole in it would misstate the trend.
+ */
+export declare const readDeliveryMetricsHistory: (value: unknown) => DeliveryMetricsHistory | null;
+/** The most recent recorded day, whatever order the days arrive in; undefined when none is recorded. */
+export declare const latestRecordedDay: (history: DeliveryMetricsHistory) => DeliveryMetricsHistoryPoint | undefined;
+/**
+ * "Delivery [id: 11] · Delivery Date Tue 15 Dec 2026 · recorded since Tue 15 Sep 2026". The read carries no
+ * Delivery name, so its id stands in; the last part is left out until a first day is recorded.
+ */
+export declare const describeDeliveryMetricsHeading: (history: DeliveryMetricsHistory, deliveryId: number, terms: Terms) => string;
+/** The day-by-day table's column headings. */
+export declare const describeRecordedDayHeadings: (terms: Terms) => string[];
+/** One recorded day as a row, in the order of its headings. */
+export declare const describeRecordedDayRow: (day: DeliveryMetricsHistoryPoint) => string[];
+/** The title over one day's detail: "On Tue 6 Oct 2026". */
+export declare const describeRecordedDayTitle: (day: DeliveryMetricsHistoryPoint) => string;
+/** The per-Feature table's column headings, as the web's Feature grid names them. */
+export declare const describeDeliveryFeatureHeadings: (terms: Terms) => string[];
+/** One Feature as it stood that day, in the order of its headings. */
+export declare const describeDeliveryFeatureRow: (feature: DeliveryFeatureMetric) => string[];
+/** The forecast distribution's column headings. */
+export declare const describeDeliveryChanceHeadings: () => string[];
+/** One chance of the day's forecast: "85%" and the day it is that likely to be done by. */
+export declare const describeDeliveryChanceRow: (chance: DeliveryWhenDistributionPoint) => string[];
+//#endregion
+//#region src/featureWording.d.ts
+/** When work on a Feature begins, as the server decided it: observed, forecast, or not known. */
+export type FeatureStart = {
+  readonly observedOn: string | undefined;
+  readonly likelyBy: string | undefined;
+};
+/** One Feature as a row of the Feature list states it. */
+export type FeatureListItem = {
+  readonly referenceId: string;
+  readonly name: string;
+  readonly state: string;
+  readonly totalWork: number;
+  readonly remainingWork: number;
+  readonly cannotBeForecast: boolean;
+  readonly start: FeatureStart;
+  readonly likelyBy: string | undefined;
+};
+/**
+ * Every Feature in the answer, or null when it is not a list or any one of them comes without its
+ * reference, name, state or per-Team work: a row that cannot say how far along it is would misstate the list.
+ */
+export declare const readFeatureList: (value: unknown) => FeatureListItem[] | null;
+/** How many Features the answer holds, in the instance's words: "No Features", "1 Feature", "3 Features". */
+export declare const describeFeatureListCount: (count: number, terms: Terms) => string;
+/** The Feature list's column headings, narrowed to the 85% chance of its completion forecast. */
+export declare const describeFeatureListHeadings: (terms: Terms) => string[];
+/** How much of the Feature's work is done, over every Team: "8 of 13 Work Items". */
+export declare const describeFeatureProgress: (feature: Pick<FeatureListItem, "totalWork" | "remainingWork">, terms: Terms) => string;
+/**
+ * When work begins, as the web's Feature list says it. A day work already began is a fact, so it outranks a
+ * Team without history; that Team only stops anyone saying when work will begin.
+ */
+export declare const describeFeatureStart: (feature: Pick<FeatureListItem, "start" | "cannotBeForecast">) => string;
+/** The day the Feature is 85% likely to be done by, "Cannot forecast", or the mark when none was sent. */
+export declare const describeFeatureCompletion: (feature: Pick<FeatureListItem, "likelyBy" | "cannotBeForecast">) => string;
+/** One Feature as a row of the list, in the order of its headings. */
+export declare const describeFeatureRow: (feature: FeatureListItem, terms: Terms) => string[];
+/** One Work Item of a Feature as the Feature's Work Items list states it. */
+export type FeatureWorkItem = {
+  readonly referenceId: string;
+  readonly name: string;
+  readonly type: string;
+  readonly state: string;
+};
+/** Every Work Item in the answer, or null when it is not a list or any one lacks its reference, name, type or state. */
+export declare const readFeatureWorkItems: (value: unknown) => FeatureWorkItem[] | null;
+/**
+ * The first Feature of an answer as a heading names it, its reference before its name:
+ * "OE-002 Deep-sea camera stream". Undefined when the answer holds no named Feature.
+ */
+export declare const describeFeatureTitle: (value: unknown) => string | undefined;
+/** "OE-002 Deep-sea camera stream · 3 Work Items", named by whatever stands in for the Feature. */
+export declare const describeFeatureWorkItemsHeading: (featureName: string, count: number, terms: Terms) => string;
+/** The column headings of a Feature's Work Items. */
+export declare const describeFeatureWorkItemHeadings: () => string[];
+/** One Work Item as a row of the list, in the order of its headings. */
+export declare const describeFeatureWorkItemRow: (item: FeatureWorkItem) => string[];
+//#endregion
+//#region src/forecastDisplayRules.d.ts
+export type ForecastLevelName = "Certain" | "Confident" | "Realistic" | "Risky";
+export type LikelihoodPrecision = "round" | "fixed2";
+export declare const CANNOT_FORECAST_SHORT = "Cannot forecast";
+export declare const INSUFFICIENT_FORECAST_DATA_SHORT = "Not enough data";
+export declare const INSUFFICIENT_FORECAST_DATA_SENTENCE = "Not enough data yet — need at least 5 days with completed items to forecast.";
+export declare const levelOf: (chance: number | null) => ForecastLevelName | null;
+export declare const formatLikelihood: (value: number, options: {
+  readonly hasRemainingWork: boolean;
+  readonly precision: LikelihoodPrecision;
+}) => string;
+export declare const likelihoodAnswer: (facts: {
+  readonly likelihood: number | null;
+  readonly cannotBeForecast: boolean;
+  readonly hasRemainingWork: boolean;
+  readonly hasSufficientData?: boolean;
+  readonly precision: LikelihoodPrecision;
+}) => string;
+export declare const OVERDUE_SHORT = "Overdue";
+/**
+ * A Delivery card's answer: its likelihood, or "Overdue" once its date has passed. Overdue says more than a
+ * number for a date already gone, but not more than "Cannot forecast", so the web shows both of those.
+ */
+export declare const deliveryLikelihoodAnswer: (facts: Parameters<typeof likelihoodAnswer>[0] & {
+  readonly isOverdue?: boolean;
+}) => string;
+//#endregion
+//#region src/forecastWording.d.ts
+/** One row of the When table: the chance of being done by a calendar day. */
+export type ForecastChanceByDay = {
+  readonly probability: number;
+  readonly expectedDate: string;
+};
+/** One row of the How Many table: the chance of getting this many done. */
+export type ForecastChanceOfCount = {
+  readonly probability: number;
+  readonly value: number;
+};
+/** The manual forecast as the Forecast tab states it. */
+export type ManualForecastView = {
+  readonly remainingItems: number;
+  readonly targetDate: string | null;
+  readonly likelihood: number | null;
+  readonly whenForecasts: readonly ForecastChanceByDay[];
+  readonly howManyForecasts: readonly ForecastChanceOfCount[];
+  readonly filterApplied: boolean | undefined;
+  readonly hasSufficientData: boolean | undefined;
+};
+/** The manual forecast's facts, or null when one it cannot be stated without is missing or mistyped. */
+export declare const readManualForecast: (value: unknown) => ManualForecastView | null;
+/** "Gravity · 25 Work Items · target Fri 30 Oct 2026", naming the filtered Throughput when it was used. */
+export declare const describeManualForecastSummary: (forecast: ManualForecastView, wording: AnswerWording) => string;
+/** The When table's title, or null when there is no When table to show. */
+export declare const describeWhenTitle: (forecast: ManualForecastView, wording: AnswerWording) => string | null;
+/** The How Many table's title, or null when there is no How Many table to show. */
+export declare const describeHowManyTitle: (forecast: ManualForecastView, wording: AnswerWording) => string | null;
+/**
+ * "Likelihood to close 25 Work Items by Fri 30 Oct 2026: 48.20%", or why there is no number. Only a
+ * forecast asked both how many and by when has a likelihood to state.
+ */
+export declare const describeManualForecastLikelihood: (forecast: ManualForecastView, wording: AnswerWording) => string | null;
+/** The backtest as Backtest Results states it: the forecast percentiles for a past period and what was actually done. */
+export type BacktestView = {
+  readonly startDate: string;
+  readonly endDate: string;
+  readonly historicalStartDate: string;
+  readonly historicalEndDate: string;
+  readonly percentiles: readonly ForecastChanceOfCount[];
+  readonly actualThroughput: number;
+};
+/** The backtest's facts, or null when one it cannot be stated without is missing or mistyped. */
+export declare const readBacktest: (value: unknown) => BacktestView | null;
+/**
+ * The percentiles lowest chance first, split where the actual falls, as the chart's dashed line sits
+ * among the bars. An actual equal to a percentile goes after it: that percentile was reached.
+ */
+export declare const placeActualAmongPercentiles: ({ percentiles, actualThroughput }: Pick<BacktestView, "percentiles" | "actualThroughput">) => {
+  readonly above: ForecastChanceOfCount[];
+  readonly below: ForecastChanceOfCount[];
+};
+/** "Gravity · Backtest Results". */
+export declare const describeBacktestSummary: (wording: AnswerWording) => string;
+/** "Period: Tue 1 Sep 2026 to Wed 30 Sep 2026 (historical data: Wed 1 Jul 2026 to Mon 31 Aug 2026)". */
+export declare const describeBacktestPeriod: (backtest: BacktestView) => string;
+/** "Actual Throughput: 21 Work Items". */
+export declare const describeBacktestActual: (backtest: BacktestView, wording: AnswerWording) => string;
+//#endregion
+//#region src/housekeepingWording.d.ts
+/**
+ * Every recurring blackout rule in the list, or null when the answer is not a list or any one of them
+ * lacks the schedule Lighthouse words for it.
+ */
+export declare const readBlackoutRules: (value: unknown) => RecurringBlackoutRule[] | null;
+/** The list's title, as the settings page heads it. */
+export declare const BLACKOUT_RULE_LIST_TITLE = "Recurring blackout rules";
+/** The list's column headings, as the settings page heads them. */
+export declare const BLACKOUT_RULE_LIST_HEADINGS: readonly ["Schedule", "Description"];
+/** How many rules there are: "No recurring blackout rules", "1 recurring blackout rule", "2 recurring blackout rules". */
+export declare const describeBlackoutRuleCount: (count: number) => string;
+/** What the list says when there is nothing in it. */
+export declare const describeNoBlackoutRules: () => string;
+/** A rule's schedule cell: its id, then Lighthouse's own summary of the schedule, word for word. */
+export declare const describeBlackoutRuleSchedule: ({ id, summary }: Pick<RecurringBlackoutRule, "id" | "summary">) => string;
+/** "Lighthouse v26.10.3.6", as the footer shows it, or null when the answer is not a version. */
+export declare const describeVersion: (value: unknown) => string | null;
+/** The sentence a successful health check answers with, naming the Lighthouse it reached. */
+export declare const describeReachable: (connection: CliConnection) => string;
+/** What a successful health check says when it does not know which endpoint it reached. */
+export declare const LIGHTHOUSE_IS_REACHABLE = "Lighthouse is reachable.";
+/** One Work Tracking System connection as the Overview lists it. */
+export type WorkTrackingConnectionListItem = {
+  readonly id: number;
+  readonly name: string;
+  readonly workTrackingSystem: string;
+};
+/** One option of a connection, labelled as the editor labels it; a secret carries no value at all. */
+export type WorkTrackingConnectionOption = {
+  readonly label: string;
+  readonly isSecret: true;
+} | {
+  readonly label: string;
+  readonly isSecret: false;
+  readonly value: string;
+};
+export type WorkTrackingConnectionDetails = WorkTrackingConnectionListItem & {
+  readonly options: readonly WorkTrackingConnectionOption[];
+};
+/** Every connection in the list, or null when the answer is not a list or any one of them lacks its name or type. */
+export declare const readWorkTrackingConnections: (value: unknown) => WorkTrackingConnectionListItem[] | null;
+/**
+ * One connection with its options labelled as the editor labels them, or null when it arrives without its
+ * options or any option lacks its key or its secret flag.
+ */
+export declare const readWorkTrackingConnection: (value: unknown) => WorkTrackingConnectionDetails | null;
+/**
+ * A copy of a connection, or a list of them, with every option value that is not known to be safe to show
+ * replaced by the secret stand-in. Only an option that says it is not secret, and that its authentication
+ * method does not declare secret, keeps its value: a server that sends a shape lh does not recognise has
+ * already shown it cannot be trusted to flag its secrets.
+ */
+export declare const hideConnectionSecrets: (value: unknown) => unknown;
+/** The list's column headings, as the Overview heads them. */
+export declare const WORK_TRACKING_CONNECTION_LIST_HEADINGS: readonly ["Name", "Type"];
+/** The option table's column headings. */
+export declare const WORK_TRACKING_OPTION_HEADINGS: readonly ["Option", "Value"];
+/** What stands in for a secret's value, which is never shown. */
+export declare const SECRET_NOT_SHOWN = "(secret, not shown)";
+/** A connection by name with its id beside it: "Letpeoplework Jira [id: 1]". */
+export declare const describeConnectionName: ({ id, name }: Pick<WorkTrackingConnectionListItem, "id" | "name">) => string;
+/** "Type: Jira". */
+export declare const describeConnectionType: ({ workTrackingSystem }: Pick<WorkTrackingConnectionListItem, "workTrackingSystem">) => string;
+/** An option's value cell; a secret's reads the same whatever Lighthouse sent. */
+export declare const describeOptionValue: (option: WorkTrackingConnectionOption) => string;
+/** How many connections there are, in the instance's words: "No Work Tracking Systems", "1 Work Tracking System". */
+export declare const describeWorkTrackingSystemCount: (count: number, terms: Terms) => string;
+/**
+ * A connection named with its type, or null when it lacks either. It is built from the name and type alone,
+ * so no option's value can ever reach it.
+ */
+export declare const describeConnectionSummary: (value: unknown) => string | null;
+//#endregion
+//#region src/metricsWording.d.ts
+type Facts = Readonly<Record<string, unknown>>;
+/** A metric Lighthouse would not answer, in the words the command reports it with. */
+export type MetricRefusal = {
+  readonly refused: string;
+};
+/** A metric's view, or why Lighthouse would not give it. */
+export type MetricAnswer<T> = T | MetricRefusal;
+export declare const isMetricRefusal: (value: unknown) => value is MetricRefusal;
+/** The metric's view, its refusal, or null when it is in a shape no reader knows. */
+export declare const readMetricAnswer: <T>(value: unknown, read: (value: unknown) => T | null) => MetricAnswer<T> | null;
+export type MetricsScope = "team" | "portfolio";
+/** What the metrics composite is about: whose metrics, and over which days. */
+export type MetricsSubject = {
+  readonly scope: MetricsScope;
+  readonly id: number;
+  readonly startDate: string;
+  readonly endDate: string;
+  readonly sections: Facts;
+};
+export declare const readMetricsSubject: (value: unknown) => MetricsSubject | null;
+export type DailyCount = {
+  readonly date: string;
+  readonly count: number;
+};
+/** Throughput or Arrivals: the total over the range and the count of each day. */
+export type DailyCountChartView = {
+  readonly startDate: string;
+  readonly endDate: string;
+  readonly total: number;
+  readonly daily: readonly DailyCount[];
+};
+type DailyCountsView = Omit<DailyCountChartView, "total">;
+declare const readDailyCountChart: (value: unknown) => DailyCountChartView | null;
+export declare const readThroughput: typeof readDailyCountChart;
+export declare const readArrivals: typeof readDailyCountChart;
+/**
+ * A run chart as Lighthouse sends it, the Work Items counted on each day keyed by the day's offset from the
+ * range's first day, read as the total and the count of each day. Without a total the days are summed.
+ */
+export declare const readRunChart: (value: unknown, range: MetricsDateRange) => DailyCountChartView | null;
+/** A Work Item in progress; an older Lighthouse does not say whether it is blocked. */
+export type InProgressItem = {
+  readonly isBlocked: boolean | undefined;
+  readonly referenceId?: string;
+  readonly name?: string;
+  readonly state?: string;
+  readonly workItemAge?: number;
+  readonly blockedSince?: string;
+};
+export type InProgressNowView = {
+  readonly asOfDate: string;
+  readonly count: number;
+  readonly items: readonly InProgressItem[];
+};
+export type WipView = {
+  readonly current: MetricAnswer<InProgressNowView>;
+  readonly overTime: MetricAnswer<DailyCountsView>;
+};
+/** What is in progress on a day, read from the bare list of Work Items the server answers with. */
+export declare const readInProgressItems: (value: unknown, asOfDate: string) => InProgressNowView | null;
+export declare const readWip: (value: unknown) => WipView | null;
+export type PercentileValue = {
+  readonly percentile: number;
+  readonly value: number;
+};
+declare const readPercentileValues: (value: unknown) => readonly PercentileValue[] | null;
+export type ClosedItem = {
+  readonly id: number;
+  readonly name: string;
+  readonly referenceId?: string;
+  readonly closedDate?: string;
+  readonly cycleTime?: number;
+};
+export type CycleTimeView = {
+  readonly percentiles: MetricAnswer<readonly PercentileValue[]>;
+  readonly closedItems: MetricAnswer<readonly ClosedItem[]>;
+};
+export declare const readCycleTime: (value: unknown) => CycleTimeView | null;
+export declare const readWorkItemAgePercentiles: typeof readPercentileValues;
+export declare const readCycleTimePercentiles: typeof readPercentileValues;
+export declare const readWorkItemAge: (value: unknown) => WorkItemAgeOverTimeResult | null;
+export declare const readTotalWorkItemAge: (value: unknown) => TotalWorkItemAgeOverTimeResult | null;
+/** The score, absent when Lighthouse sent none. */
+export type PredictabilityScoreView = {
+  readonly score: number | undefined;
+};
+export declare const readPredictabilityScore: (value: unknown) => PredictabilityScoreView | null;
+/** A recorded history over the range, one entry per recorded day. */
+export type MetricHistoryView<T> = {
+  readonly startDate: string;
+  readonly endDate: string;
+  readonly history: readonly T[];
+};
+export declare const readBlocked: (value: unknown) => MetricHistoryView<BlockedCountSnapshot> | null;
+/** The percentiles' history and how many days back each day's percentiles look, when Lighthouse says. */
+export type PercentilesOverTimeView = MetricHistoryView<PercentilesOverTimeSnapshot> & {
+  readonly horizon: number | undefined;
+};
+export declare const readPercentilesOverTime: (value: unknown) => PercentilesOverTimeView | null;
+export declare const readProcessBehaviorOverTime: (value: unknown) => MetricHistoryView<ProcessBehaviorSnapshot> | null;
+declare const readStates: (value: unknown) => CumulativeStateTimeResult | null;
+declare const readContributors: (value: unknown) => CumulativeStateTimeItemsResult | null;
+/** Time in State's bar on its own, as one read answers it. */
+export declare const readTimeInStateBar: typeof readStates;
+/** The Work Items contributing to one state of Time in State, as one read answers them. */
+export declare const readTimeInStateContributors: typeof readContributors;
+/** Time in State: the bar, the Work Items it can be narrowed to, and one state's contributors when one was asked for. */
+export type CumulativeStateTimeView = {
+  readonly bar: MetricAnswer<CumulativeStateTimeResult>;
+  readonly candidates: MetricAnswer<CumulativeStateTimeCandidatesResult>;
+  readonly items: MetricAnswer<CumulativeStateTimeItemsResult> | undefined;
+};
+export declare const readCumulativeStateTime: (value: unknown) => CumulativeStateTimeView | null;
+/** The Team's or Portfolio's System WIP Limit; absent when none is set, as the web leaves it out. */
+export declare const readSystemWipLimit: (value: unknown) => number | undefined;
+/** The name of the Team's cycle time definition with this id; absent when the settings do not carry it. */
+export declare const readCycleTimeDefinitionName: (settings: unknown, definitionId: number) => string | undefined;
+/** One line of the headline: what it is, its number, and what the number is out of. */
+export type MetricLine = {
+  readonly label: string;
+  readonly value: string;
+  readonly detail: string;
+};
+export declare const UNKNOWN_SHAPE_NOTE = "shown only with --json (unknown shape)";
+/** What the dashboard says under its Predictability Score, word for word. */
+export declare const PREDICTABILITY_SCORE_EXPLANATION = "The predictability score shows how \"close\" the 50% and 95% chance are. The closer they are, the more predictable you are. 100% means they are exactly the same value. The higher number, the better.";
+/** What an empty over-time chart says on the web. */
+export declare const OVER_TIME_EMPTY_SENTENCE = "Nothing to show for the selected range. Days appear here as Lighthouse records them.";
+/** Every part of the headline that can be refused or unreadable on its own. */
+export type MetricsHeadlinePart = "wip" | "throughput" | "arrivals" | "blocked" | "totalWorkItemAge" | "predictabilityScore" | "cycleTimePercentiles" | "workItemAgePercentiles" | "workItemAge" | "cumulativeStateTime" | "percentilesOverTime" | "processBehaviorOverTime";
+/** "1 day", "12 days". */
+export declare const describeDays: (days: number) => string;
+/** The label each part of the headline goes by, in the instance's words. */
+export declare const metricsHeadlineLabel: (part: MetricsHeadlinePart, scope: MetricsScope, terms: Terms) => string;
+/** A part Lighthouse refused, its reason in the number's place. */
+export declare const describeRefusedMetric: (label: string, refusal: MetricRefusal) => MetricLine;
+/** A part in a shape this version cannot read: the facts are still in --json. */
+export declare const describeUnknownMetric: (label: string) => MetricLine;
+/** How many days a range covers, both ends included. */
+export declare const daysInRange: (startDate: string, endDate: string) => number;
+/** "Gravity · Mon 7 Sep 2026 – Tue 6 Oct 2026 (30 days)". */
+export declare const describeMetricsHeading: (subject: Pick<MetricsSubject, "startDate" | "endDate">, wording: AnswerWording) => string;
+/** "Gravity · as of Tue 6 Oct 2026", for a metric that answers about the range's last day. */
+export declare const describeAsOfHeading: (subject: Pick<MetricsSubject, "endDate">, wording: AnswerWording) => string;
+/** "Work Items in Progress  9  System WIP Limit: 10 Work Items", the limit left out when none is set. */
+export declare const describeInProgressNow: (now: InProgressNowView, scope: MetricsScope, terms: Terms, systemWipLimit: number | undefined) => MetricLine;
+/** "Blocked Work Items  2", or null when Lighthouse does not say which items are blocked. */
+export declare const describeBlockedNow: (now: InProgressNowView, scope: MetricsScope, terms: Terms) => MetricLine | null;
+/**
+ * The sentences that stand in for what a WIP answer cannot show: no System WIP Limit, a Lighthouse that does
+ * not say which Work Items are Blocked (which is not the same as none being Blocked), and nothing in progress.
+ * A limit of null means the Team or Portfolio could not be read; it may well have one, so nothing is said.
+ */
+export declare const describeWhatWipLeavesUnsaid: (now: InProgressNowView, scope: MetricsScope, terms: Terms, systemWipLimit: number | undefined | null) => readonly string[];
+/** "Total Throughput  31  1.0 / day". */
+export declare const describeTotalThroughput: (chart: DailyCountChartView, scope: MetricsScope, terms: Terms) => MetricLine;
+/** "Total Arrivals  28  0.9 / day". */
+export declare const describeTotalArrivals: (chart: DailyCountChartView, scope: MetricsScope, terms: Terms) => MetricLine;
+/** "Total Work Item Age  84 days  across 9 Work Items", as on the last recorded day. */
+export declare const describeTotalWorkItemAge: (view: TotalWorkItemAgeOverTimeResult, scope: MetricsScope, terms: Terms) => MetricLine;
+/** "Predictability Score  63.4%", as the web shows it to one decimal. */
+export declare const describePredictabilityScore: (view: PredictabilityScoreView, scope: MetricsScope, terms: Terms) => MetricLine;
+/** "95th", "1st", "22nd". */
+export declare const ordinalOf: (value: number) => string;
+/**
+ * The percentile table's rows, header first and the highest percentile next, Cycle Time beside Work Item
+ * Age; a side that has no value for a percentile reads "—". Empty when neither side can be shown.
+ */
+export declare const describePercentileRows: (cycleTime: readonly PercentileValue[] | undefined, workItemAge: readonly PercentileValue[] | undefined, terms: Terms) => readonly (readonly string[])[];
+/** "Over time (one row per recorded day: lh metrics team --id 3 --metrics <name>)". */
+export declare const describeOverTimeHeading: (subject: Pick<MetricsSubject, "scope" | "id">) => string;
+/** "Cycle Time 85th percentile  14 days on Mon 7 Sep → 12 days on Tue 6 Oct  29 days recorded". */
+export declare const describePercentilesOverTime: (view: MetricHistoryView<PercentilesOverTimeSnapshot>, scope: MetricsScope, terms: Terms) => MetricLine;
+/** "Throughput process limits  0 – 3.1 / day, average 1.0, on Tue 6 Oct  29 days recorded", as on the last recorded day. */
+export declare const describeProcessBehaviorOverTime: (view: MetricHistoryView<ProcessBehaviorSnapshot>, scope: MetricsScope, terms: Terms) => MetricLine;
+/** "Blocked Work Items  1 on Mon 7 Sep → 2 on Tue 6 Oct  30 days recorded". */
+export declare const describeBlockedOverTime: (view: MetricHistoryView<BlockedCountSnapshot>, scope: MetricsScope, terms: Terms) => MetricLine;
+/**
+ * One metric over its days: the sentence that answers it, its day table with the header row first, and
+ * the web's empty-chart sentence in place of a table when Lighthouse has recorded no day. A metric the
+ * dashboard shows as more than one table lists them in order, and one with only a sentence lists none.
+ */
+export type MetricDayView = {
+  readonly sentence: string;
+} & (MetricDays | {
+  readonly tables: readonly MetricDays[];
+});
+/** A table, or the sentence that stands in for it, with the title the dashboard puts above it, if any. */
+export type MetricDays = {
+  readonly title?: string;
+} & ({
+  readonly rows: readonly (readonly string[])[];
+} | {
+  readonly note: string;
+});
+/** "Total Throughput: 31 Work Items, 1.0 / day", then the count closed on each day. */
+export declare const describeThroughputDays: (chart: DailyCountChartView, scope: MetricsScope, terms: Terms) => MetricDayView;
+/** "Total Arrivals: 28 Work Items, 0.9 / day", then the count started on each day. */
+export declare const describeArrivalsDays: (chart: DailyCountChartView, scope: MetricsScope, terms: Terms) => MetricDayView;
+/**
+ * "Work Items in Progress: 9 (System WIP Limit: 10 Work Items)", then each Work Item in progress, oldest
+ * first, and the count in progress on each day.
+ */
+export declare const describeWipDays: (now: InProgressNowView, overTime: DailyCountsView, scope: MetricsScope, terms: Terms, systemWipLimit: number | undefined) => MetricDayView;
+/** "Cycle Time Percentiles: 50th 5 days · … · 95th 21 days", then each closed Work Item and its Cycle Time. */
+export declare const describeCycleTimeDays: (percentiles: readonly PercentileValue[], closedItems: readonly ClosedItem[], terms: Terms, definitionName?: string) => MetricDayView;
+/** "Work Item Age Percentiles: 50th 3 days · 70th 6 days · 85th 11 days · 95th 18 days". */
+export declare const describeWorkItemAgePercentiles: (percentiles: readonly PercentileValue[], terms: Terms) => string;
+/**
+ * "Work Item Age Percentiles: 50th 3 days · … · 95th 18 days", then each day's oldest Work Item and how
+ * many were in progress; every item of a day is in --json.
+ */
+export declare const describeWorkItemAgeDays: (percentiles: readonly PercentileValue[], overTime: WorkItemAgeOverTimeResult, scope: MetricsScope, terms: Terms) => MetricDayView;
+/**
+ * "Predictability Score: 63.4%", then what the dashboard says the score means; no table, because the
+ * chart's marks need facts --json does not carry.
+ */
+export declare const describePredictabilityScoreDays: (view: PredictabilityScoreView, scope: MetricsScope, terms: Terms) => MetricDayView;
+/** "Blocked Work Items: 1 on Mon 7 Sep → 2 on Tue 6 Oct", then each recorded day's count. */
+export declare const describeBlockedDays: (view: MetricHistoryView<BlockedCountSnapshot>, scope: MetricsScope, terms: Terms) => MetricDayView;
+/** "Total Work Item Age: 84 days across 9 Work Items on Tue 6 Oct 2026", then each day's total. */
+export declare const describeTotalWorkItemAgeDays: (view: TotalWorkItemAgeOverTimeResult, scope: MetricsScope, terms: Terms) => MetricDayView;
+/** "Cycle Time over the last 30 days, per recorded day", then each recorded day's percentiles. */
+export declare const describePercentilesOverTimeDays: (view: PercentilesOverTimeView, terms: Terms) => MetricDayView;
+/** "Throughput natural process limits per recorded day", then each recorded day's limits. */
+export declare const describeProcessBehaviorOverTimeDays: (view: MetricHistoryView<ProcessBehaviorSnapshot>, terms: Terms) => MetricDayView;
+/** What the web's Time in State chart says when it has no state to show. */
+export declare const NO_DATA_YET = "No data yet.";
+/**
+ * How many Work Items Time in State is across: the ones picked with --item-ids, otherwise every one the web
+ * offers to pick from; absent when Lighthouse refused that list and none were picked.
+ */
+export declare const timeInStateItemCount: (view: CumulativeStateTimeView, picked: number | undefined) => number | undefined;
+/** "Time in State  4 states  across 42 Work Items". */
+export declare const describeTimeInState: (bar: CumulativeStateTimeResult, itemCount: number | undefined, scope: MetricsScope, terms: Terms) => MetricLine;
+/**
+ * "Time in State across 42 Work Items", then one row per state in workflow order with the facts the web's
+ * tooltip shows, and the Work Items contributing to a state when one was asked for. Mean and median are
+ * printed as Lighthouse sent them, never worked out again.
+ */
+export declare const describeTimeInStateDays: (bar: CumulativeStateTimeResult, itemCount: number | undefined, contributors: CumulativeStateTimeItemsResult | undefined, scope: MetricsScope, terms: Terms) => MetricDayView;
+/** One state's drill-down on its own, answered with the title the web's dialog puts above it. */
+export declare const describeTimeInStateContributorDays: (contributors: CumulativeStateTimeItemsResult, scope: MetricsScope, terms: Terms) => MetricDayView;
+/**
+ * One metric as an assistant is told it: the heading and sentence lh prints above the metric's tables, and
+ * the web's words where a note stands in for a table, such as a history with no recorded day. Never a table.
+ */
+export declare const describeMetricSummary: (heading: string, view: MetricDayView) => string;
+/**
+ * Where "at risk" starts, the line Lighthouse's own SLE Risk widget draws. Seventy sits on the at-risk
+ * side; nothing else in the clients decides what counts as at risk.
+ */
+export declare const SLE_RISK_AT_RISK_FROM = 70;
+export declare const isAtRiskOfMissingTheSle: (risk: number) => boolean;
+/** One Work Item's SLE Risk; the miss count is null for a Work Item already past the SLE. */
+export type SleRiskView = {
+  readonly referenceId: string;
+  readonly risk: number;
+  readonly finishedItemsStillOpenAtThisAge: number;
+  readonly finishedItemsThatWentOnToMiss: number | null;
+};
+/** Every Work Item's SLE Risk as Lighthouse lists them, or null when the answer is in a shape it does not know. */
+export declare const readSleRisk: (value: unknown) => readonly SleRiskView[] | null;
+export type ServiceLevelExpectation = {
+  readonly probability: number;
+  readonly days: number;
+};
+/** The Team's SLE; absent when none is set, which Lighthouse stores as zeros. */
+export declare const readServiceLevelExpectation: (value: unknown) => ServiceLevelExpectation | undefined;
+/** The SLE Risk's title, the sentence that counts what is at risk, and one row per Work Item, highest risk first. */
+export type SleRiskWording = {
+  readonly title: string;
+  readonly sentence: string | null;
+  readonly rows: readonly (readonly string[])[];
+};
+/**
+ * "2 of 8 Work Items in progress are at risk of missing the SLE (85% within 7 days).", then every Work Item
+ * highest risk first with its risk and the finished Work Items behind it. The names and ages come from
+ * today's Work Items in progress; without them each Work Item is still listed by its reference. An SLE of
+ * null means the Team could not be read: it may well have one, so an empty answer gets no sentence at all.
+ */
+export declare const describeSleRiskNow: (entries: readonly SleRiskView[], wording: AnswerWording, sle: ServiceLevelExpectation | undefined | null, inProgress: readonly InProgressItem[] | undefined) => SleRiskWording;
+/** One day on a chart, the signals Lighthouse found on it by their wire names, and whether it was a blackout day. */
+export type ProcessBehaviorChartDay = {
+  readonly day: string;
+  readonly signals: readonly string[];
+  readonly blackout: boolean;
+};
+/**
+ * A chart as far as it can be said. `status` and `baselineConfigured` are null when the server did not send
+ * them (an older Lighthouse), so nothing is claimed about what was never said.
+ */
+export type ProcessBehaviorChartView = {
+  readonly status: string | null;
+  readonly statusReason: string;
+  readonly baselineConfigured: boolean | null;
+  readonly days: readonly ProcessBehaviorChartDay[];
+};
+/**
+ * A chart's status, baseline and days with their signals, or null when a signal arrives as anything but its
+ * name: a number would have to be guessed at, and a guessed signal is worse than none.
+ */
+export declare const readProcessBehaviorChart: (value: unknown) => ProcessBehaviorChartView | null;
+/** "Total Work Item Age Process Behaviour Chart": a chart's title as the web titles it. */
+export declare const processBehaviorChartTitle: (metricType: ProcessBehaviorMetricType, terms: Terms) => string;
+/** A chart's title and what Lighthouse found on it. */
+export type ProcessBehaviorChartWording = {
+  readonly title: string;
+  readonly sentence: string;
+};
+/**
+ * "Total Work Item Age Process Behaviour Chart", then each signal with the days it fired, or "No signals"; a chart
+ * that is not ready or has no baseline names no signal, and a blackout day is listed as one, never as a signal.
+ */
+export declare const describeProcessBehaviorChart: (chart: ProcessBehaviorChartView, metricType: ProcessBehaviorMetricType, terms: Terms) => ProcessBehaviorChartWording;
+//#endregion
+//#region src/ownerWording.d.ts
+/** What owns Features in Lighthouse: a Team or a Portfolio. */
+export type OwnerKind = "team" | "portfolio";
+/** One Team or Portfolio as a list row shows it. Fields Lighthouse did not send stay undefined. */
+export type OwnerListItem = {
+  readonly id: number;
+  readonly name: string;
+  readonly featureCount: number | undefined;
+  readonly tags: readonly string[];
+  readonly lastUpdated: string | undefined;
+};
+/** A mark for a cell Lighthouse sent nothing for. */
+export declare const NOT_SENT = "—";
+/**
+ * Every Team or Portfolio in the list, or null when the answer is not a list or any one of them comes
+ * without its id or name: a row that cannot say what it is would misname the whole list.
+ */
+export declare const readOwnerList: (value: unknown) => OwnerListItem[] | null;
+/** The list's title, as the Overview heads it: "Teams" or "Portfolios" in the instance's words. */
+export declare const describeOwnerListTitle: (kind: OwnerKind, terms: Terms) => string;
+/** How many Teams or Portfolios the list holds, in the instance's words: "No Teams", "1 Team", "7 Teams". */
+export declare const describeOwnerCount: (kind: OwnerKind, count: number, terms: Terms) => string;
+/** The list's column headings, as the Overview's table has them. */
+export declare const describeOwnerListHeadings: (terms: Terms) => string[];
+/** A Team or Portfolio by name with its id beside it: "Gravity [id: 3]". */
+export declare const describeOwnerName: ({ id, name }: Pick<OwnerListItem, "id" | "name">) => string;
+/** How many Features it owns: "1 Feature", "6 Features", or the mark when Lighthouse sent none. */
+export declare const describeFeatureCount: (count: number | undefined, terms: Terms) => string;
+/** The tags as one cell, empty when there are none. */
+export declare const describeTags: (tags: readonly string[]) => string;
+/** When it was last updated, in the reader's local time; the mark when it never was. */
+export declare const describeLastUpdated: (wire: string | undefined) => string;
+/** A Team's Throughput dates, already resolved, and whether they roll forward or stay fixed. */
+export type ThroughputDates = {
+  readonly start: string;
+  readonly end: string;
+  readonly fixed: boolean | undefined;
+};
+/** Another Team or Portfolio by what it is called and its id. */
+export type OwnerReference = Pick<OwnerListItem, "id" | "name">;
+/**
+ * A Team as its page states it. A setting left unset, which Lighthouse sends as 0, and a fact it did not
+ * send both stay undefined.
+ */
+export type TeamSummary = {
+  readonly id: number;
+  readonly name: string;
+  readonly lastUpdated: string | undefined;
+  readonly sleProbability: number | undefined;
+  readonly sleRange: number | undefined;
+  readonly systemWipLimit: number | undefined;
+  readonly featureWip: number | undefined;
+  readonly throughput: ThroughputDates | undefined;
+  readonly portfolios: readonly OwnerReference[];
+  readonly featureCount: number | undefined;
+  readonly tags: readonly string[];
+  readonly workItemTypes: readonly string[];
+};
+/** What the Team page's quick settings say for a setting nobody gave a value. */
+export declare const NOT_SET = "Not set";
+/** The Team as its page states it, or null when the answer does not say which Team it is. */
+export declare const readTeam: (value: unknown) => TeamSummary | null;
+/**
+ * The Team page's heading and settings, one line each, in the instance's words. Tags get a line only
+ * when there are some, because Lighthouse sends a Team without them.
+ */
+export declare const describeTeamSummary: (team: TeamSummary, terms: Terms) => string[];
+/**
+ * A Portfolio as its page states it. Its Feature WIP is the number of Teams working on it, so it has no
+ * setting of its own.
+ */
+export type PortfolioSummary = {
+  readonly id: number;
+  readonly name: string;
+  readonly lastUpdated: string | undefined;
+  readonly sleProbability: number | undefined;
+  readonly sleRange: number | undefined;
+  readonly systemWipLimit: number | undefined;
+  readonly teams: readonly OwnerReference[];
+  readonly featureCount: number | undefined;
+};
+/** The Portfolio as its page states it, or null when the answer does not say which Portfolio it is. */
+export declare const readPortfolio: (value: unknown) => PortfolioSummary | null;
+/**
+ * The Portfolio page's heading and settings, one line each, in the instance's words. Its Feature WIP
+ * reads 'Not set' when no Team works on it, as the page's quick setting does.
+ */
+export declare const describePortfolioSummary: (portfolio: PortfolioSummary, terms: Terms) => string[];
+//#endregion
+//#region src/processBehaviorChartTypes.d.ts
+/** Whether a text names a chart type Lighthouse draws a Process Behaviour Chart for. */
+export declare const isProcessBehaviorMetricType: (value: string) => value is ProcessBehaviorMetricType;
+//#endregion
+//#region src/refinementWording.d.ts
+/** The words an instance may rename that the refinement need is stated in. */
+export type RefinementTerms = {
+  readonly workItem: string;
+  readonly workItems: string;
+  readonly team: string;
+  readonly refinement: string;
+};
+/** What the refinement need is stated with: the Team's name and the instance's words. */
+export type RefinementWording = {
+  readonly teamName: string;
+  readonly terms: RefinementTerms;
+};
+type Read<TValue, TError> = {
+  readonly ok: true;
+  readonly value: TValue;
+} | {
+  readonly ok: false;
+  readonly error: TError;
+};
+/** The two reads the wording comes from; each surface passes its own client. */
+export type RefinementWordingSource<TError> = {
+  readonly getTeam: (teamId: number) => Promise<Read<unknown, TError>>;
+  readonly getTerminology: LighthouseClient["getTerminology"];
+};
+/**
+ * Reads the Team's name and the instance's terminology. Terminology that cannot be read leaves the
+ * seeded words standing rather than failing the answer; a Team that cannot be read fails it.
+ */
+export declare const readRefinementWording: <TError>(source: RefinementWordingSource<TError>, teamId: number) => Promise<Read<RefinementWording, TError>>;
+/**
+ * The heading and the need sentence together, as the web page states them, or that nothing is in
+ * refinement right now.
+ */
+export declare const describeRefinementSummary: (refinement: TeamRefinement, wording: RefinementWording) => string;
+/** Where the line goes among the listed Work Items: after this many rows, saying this. */
+export type EnoughForLine = {
+  readonly afterRows: number;
+  readonly says: string;
+};
+/**
+ * The line follows the Work Item that makes up the number needed. When fewer are listed than that, it
+ * follows the last one and says all of them are needed; when none are needed, it comes first. Without
+ * a verdict to show there is no line.
+ */
+export declare const placeEnoughForLine: (refinement: TeamRefinement, terms: RefinementTerms) => EnoughForLine | null;
+/** How many of the listed Work Items carry a number: those needed, while a verdict is shown. */
+export declare const countNumberedRows: (refinement: TeamRefinement) => number;
+export type RefinementTermsSource = Pick<LighthouseClient, "getTerminology">;
+/** The instance's words alone, the seeded ones standing in when terminology cannot be read. */
+export declare const readRefinementTerms: (source: RefinementTermsSource) => Promise<RefinementTerms>;
+//#endregion
+//#region src/refinementVoteWording.d.ts
+/** An answer as the web's buttons name it: "Yes", "Yes, if…" or "No". */
+export declare const describeAnswer: (answer: RefinementAnswer) => string;
+/** Where a Work Item stands by its votes, in the web's words: "Ready", "2 more Yes needed", … */
+export declare const describeReadiness: (row: Pick<RefinementRow, "readiness" | "missingVotes">) => string;
+/**
+ * How the votes split, parts in the order Yes · Yes, if… · No and zero parts left out, with a `*` when
+ * the caller has voted; "No votes" when nobody has.
+ */
+export declare const describeVotes: (row: Pick<RefinementRow, "split" | "myVote">) => string;
+/** What to look at on a Work Item: "open question", "stage disagrees", both, or nothing. */
+export declare const describeWarnings: (row: Pick<RefinementRow, "hasOpenQuestion" | "signalsDisagree">) => string;
+/** What a vote, comment or take-back is said about: the Work Item and, without sign-in, whose it is. */
+export type RecordedFor = {
+  readonly workItem: string;
+  readonly voterName?: string | null;
+};
+/** "Recorded: Ana Lima — Yes, if… on GR-051. GR-051: 2 more Yes needed.", or "your Yes" with sign-in. */
+export declare const describeRecordedVote: ({ workItem, voterName }: RecordedFor, answer: RefinementAnswer, row: VotedRow) => string;
+/** "Recorded: Ana Lima's comment on GR-054." */
+export declare const describeRecordedComment: ({ workItem, voterName }: RecordedFor) => string;
+/** "Took back Ana Lima's vote on GR-051. GR-051: 3 more Yes needed." */
+export declare const describeTakenBack: ({ workItem, voterName }: RecordedFor, row: VotedRow) => string;
+/** Why a "Yes, if…" without its condition is not sent, ending in how this surface adds one. */
+export declare const describeMissingCondition: (howToAddIt: string) => string;
+/** Said instead of taking back when this client has no vote on the Work Item to take back. */
+export declare const describeNothingToTakeBack: (workItem: string) => string;
+export type VoteRefusalWording = {
+  /** The instance's words for the Work Item and the refinement. */
+  readonly terms: Pick<RefinementTerms, "workItem" | "refinement">;
+  /** What to say when Lighthouse needs a name, which each surface asks for its own way. */
+  readonly nameRequired: string;
+  /** What to say when Lighthouse needs a voter key, for a surface that keeps none to send. */
+  readonly keyRequired?: string;
+};
+/**
+ * Why Lighthouse would not take a vote, comment or take-back, in words the voter can act on: the web's
+ * sentence where it has one, the title of a name that is too long, otherwise its category and reason as
+ * every other command says a refusal.
+ */
+export declare const describeVoteRefusal: (error: LighthouseApiError, { terms, nameRequired, keyRequired }: VoteRefusalWording) => string;
+/** {@link describeVoteRefusal} in the instance's own words, read from the instance first. */
+export declare const readVoteRefusal: (source: RefinementTermsSource, error: LighthouseApiError, nameRequired: string, keyRequired?: string) => Promise<string>;
+//#endregion
+//#region src/refinementVoting.d.ts
+/** A "Yes, if…" names the condition it holds under, so without a comment it is not a vote yet. */
+export declare const isMissingItsCondition: (answer: RefinementAnswer, comment: string | undefined) => boolean;
+/**
+ * The reader's own vote on the Work Item, in a refinement read with this client's voter key or as the
+ * signed-in account; null when there is none. Lighthouse answers a take-back that found nothing exactly
+ * like one that did, so a client asks this first, sends nothing when there is no vote to take back, and
+ * otherwise names the answer it saw, so a vote changed since in another session is left standing.
+ */
+export declare const myVoteOn: (refinement: Pick<TeamRefinement, "workItems">, workItem: string) => RefinementAnswer | null;
+/** {@link nameOfMyVote}, read from Lighthouse; null when the log cannot be read either. */
+export declare const readNameOfMyVote: (client: Pick<LighthouseClient, "getRefinementLog">, teamId: number, workItem: string, voterKey: string | undefined) => Promise<string | null>;
+//#endregion
+//#region src/usageDataStore.d.ts
+/** The answer kept for a Lighthouse, undefined when never asked there, or "unreadable" when the file is not ours. */
+export type UsageDataStoreReading = StoredUsageDataAnswer | undefined | "unreadable";
+/**
+ * The usage data answers this machine keeps, one per Lighthouse, shared by the command line and the local
+ * MCP server. A separate file from the voter keys, so a client that only knows the voter keys never writes
+ * an answer away.
+ */
+export type UsageDataStore = {
+  readonly read: (lighthouse: string) => Promise<UsageDataStoreReading>;
+  /** Keeps a question's answer only if none is kept yet: the first answer wins. True when it was kept. */
+  readonly answer: (lighthouse: string, answer: StoredUsageDataAnswer) => Promise<boolean>;
+  /** Keeps the answer whatever was kept before. */
+  readonly replace: (lighthouse: string, answer: StoredUsageDataAnswer) => Promise<void>;
+  /**
+   * Replaces a yes only while it still holds `token`. True when it was replaced. Waiting for another writer
+   * stops, throwing, once `signal` aborts.
+   */
+  readonly renew: (lighthouse: string, token: string, answer: StoredUsageDataAnswer, signal?: AbortSignal) => Promise<boolean>;
+};
+/** The part of a store that holds one Lighthouse's answer. */
+export type LighthouseUsageDataStore = {
+  readonly read: () => Promise<UsageDataStoreReading>;
+  readonly answer: (answer: StoredUsageDataAnswer) => Promise<boolean>;
+  readonly replace: (answer: StoredUsageDataAnswer) => Promise<void>;
+  readonly renew: (token: string, answer: StoredUsageDataAnswer, signal?: AbortSignal) => Promise<boolean>;
+};
+export declare const usageDataStoreFor: (store: UsageDataStore, lighthouse: string) => LighthouseUsageDataStore;
+/** Beside the voter keys: `~/.config/lighthouse-clients/usage-data.json` by default. */
+export declare const getUsageDataStorePath: (env?: NodeJS.ProcessEnv) => string;
+/** A usage data store kept in one JSON file, readable by its owner only, never written over when unreadable. */
+export declare const createFileUsageDataStore: (filePath: string) => UsageDataStore;
+//#endregion
+//#region src/usageDataReporter.d.ts
+/** The Lighthouse calls a reporter makes, none of them with a credential. */
+export type UsageDataLighthouse = Pick<LighthouseClient, "getUsageDataState" | "grantUsageData" | "revokeUsageData" | "handInUsageData">;
+export type UsageDataReporterDependencies = {
+  readonly lighthouse: UsageDataLighthouse;
+  /** This Lighthouse's answer on this machine. */
+  readonly store: LighthouseUsageDataStore;
+  readonly source: ClientUsageDataSource;
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly now: () => Date;
+};
+/** What a person answered to the question: null when they closed it without answering. */
+export type UsageDataQuestionAnswer = "yes" | "no" | null;
+/** What a command did, and how its person can be asked when nobody has answered yet. */
+export type UsageDataStep = {
+  /** Whether the command reached Lighthouse and succeeded. */
+  readonly reached: boolean;
+  readonly occurrences: readonly UsageDataOccurrence[];
+  /** Asks the person; absent when nobody is there who could answer. */
+  readonly ask?: () => Promise<UsageDataQuestionAnswer>;
+};
+/** How a step ended. Never carries the consent token. */
+export type UsageDataOutcome = "nothing" | "sent" | "kept-yes" | "kept-no" | "unanswered" | "not-recorded";
+/** A command's own answer never waits on usage data for longer than this, whatever Lighthouse does. */
+export declare const USAGE_DATA_BUDGET_MS = 1000;
+/** How turning usage data off ended. Never carries the consent token. */
+export type UsageDataWithdrawal = "off" | "off-lighthouse-not-told" | "unreadable";
+export type UsageDataWithdrawalDependencies = {
+  readonly lighthouse: Pick<LighthouseClient, "revokeUsageData">;
+  readonly store: LighthouseUsageDataStore;
+  readonly now: () => Date;
+};
+/**
+ * Turns usage data off for one Lighthouse: keeps a No in place of whatever was kept, then withdraws a yes
+ * at Lighthouse with its token. Off is kept even when Lighthouse cannot be told; an unreadable answers file
+ * is left as it was.
+ */
+export declare const withdrawUsageData: (dependencies: UsageDataWithdrawalDependencies) => Promise<UsageDataWithdrawal>;
+/** How turning usage data on ended. Never carries the consent token. */
+export type UsageDataSwitchOn = "on" | "do-not-track" | "administrator-stopped" | "predates" | "could-not-ask" | "not-recorded" | "unreadable";
+export type UsageDataSwitchOnDependencies = {
+  readonly lighthouse: Pick<LighthouseClient, "getUsageDataState" | "grantUsageData" | "revokeUsageData">;
+  readonly store: LighthouseUsageDataStore;
+  readonly source: ClientUsageDataSource;
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly now: () => Date;
+};
+/**
+ * Turns usage data on for one Lighthouse without a question: a yes replaces whatever was kept. Nothing is
+ * asked of Lighthouse under DO_NOT_TRACK, and nothing is kept when Lighthouse refuses, predates labelled
+ * sources or cannot be asked; a yes already kept is left as it is, so no second grant is minted.
+ */
+export declare const switchUsageDataOn: (dependencies: UsageDataSwitchOnDependencies) => Promise<UsageDataSwitchOn>;
+/**
+ * Settles what a command did about usage data: asks when it should, records the answer, or sends the
+ * command's events. It never prints and never throws; anything that goes wrong ends it quietly.
+ */
+export declare const settleUsageDataStep: (dependencies: UsageDataReporterDependencies, step: UsageDataStep) => Promise<UsageDataOutcome>;
+//#endregion
+//#region src/voterKeyStore.d.ts
+/**
+ * The voter keys this machine keeps, one per Lighthouse. The command line and the local MCP server share
+ * it, so a person is one voter on a Lighthouse whichever of the two they vote from, and either can take
+ * back what the other cast.
+ */
+export type VoterKeyStore = {
+  readonly load: (lighthouse: string) => Promise<string | null>;
+  readonly save: (lighthouse: string, key: string) => Promise<void>;
+};
+/** The voter key a client keeps for the one Lighthouse it talks to. */
+export type LighthouseVoterKeyStore = {
+  readonly load: () => Promise<string | null>;
+  readonly save: (key: string) => Promise<void>;
+};
+/** The part of a store that holds one Lighthouse's key. */
+export declare const voterKeyStoreFor: (store: VoterKeyStore, lighthouse: string) => LighthouseVoterKeyStore;
+/** A fresh random voter key: 43 URL-safe characters from 32 random bytes. */
+export declare const mintVoterKey: () => string;
+/** The key already kept, or on a client's first write a fresh one, minted and kept from then on. */
+export declare const keepVoterKey: (store: LighthouseVoterKeyStore) => Promise<string>;
+/**
+ * The name a standalone Lighthouse's key is kept under. The desktop app may come back on another port,
+ * and it is still the same Lighthouse.
+ */
+export declare const STANDALONE_VOTER_KEY_SCOPE = "standalone";
+/** Beside the command line's config file: `~/.config/lighthouse-clients/voter-keys.json` by default. */
+export declare const getVoterKeyStorePath: (env?: NodeJS.ProcessEnv) => string;
+/**
+ * The name a Lighthouse's voter key is kept under: `standalone` for the desktop app, otherwise the server
+ * as the client reaches it, so `HTTPS://Lighthouse.example:443/` and `https://lighthouse.example/api` are
+ * one Lighthouse and one voter, whether `lh` or the local MCP server was given the URL.
+ */
+export declare const getVoterKeyScope: (lighthouse: string) => string;
+/**
+ * A voter key store kept in one JSON file, readable by its owner only. A file it cannot read is never
+ * written over: it may hold the keys a person's earlier votes were cast with.
+ */
+export declare const createFileVoterKeyStore: (filePath: string) => VoterKeyStore;
+//#endregion
+//#region src/writeWording.d.ts
+/** What a write did, as its confirmation opens: "Created:", "Updated:" or "Deleted:". */
+export type WriteVerb = "Created" | "Updated" | "Deleted";
+/** The Team or Portfolio a write is confirmed for: its id, and its name when there is one to give. */
+export type WrittenOwner = {
+  readonly id: number;
+  readonly name?: string;
+};
+/** The recurring blackout rule a write is confirmed for, with Lighthouse's own wording of its schedule. */
+export type WrittenBlackoutRule = Pick<RecurringBlackoutRule, "id"> & Partial<Pick<RecurringBlackoutRule, "summary" | "description">>;
+/** The id and name a Team or Portfolio write answered with, or null when the answer does not say which it is. */
+export declare const readWrittenOwner: (value: unknown) => WrittenOwner | null;
+/** The rule a blackout write answered with, or null when the answer does not say which rule it is. */
+export declare const readWrittenBlackoutRule: (value: unknown) => WrittenBlackoutRule | null;
+/** "Created: Team Lightspeed [id: 9]."; without a name, as a delete always is, "Deleted: Team [id: 9]." */
+export declare const describeOwnerWriteConfirmation: (verb: WriteVerb, kind: OwnerKind, { id, name }: WrittenOwner, terms: Terms) => string;
+/** A refresh only joins Lighthouse's queue, so the line says it was queued, not that it is done. */
+export declare const describeRefreshConfirmation: (kind: OwnerKind, id: number, terms: Terms) => string;
+/**
+ * "Created: recurring blackout rule [id: 5] — Every Friday — every 2 weeks — from 2026-10-09 — no end
+ * (Focus Friday)." The schedule is Lighthouse's own summary, word for word, so it reads as the settings
+ * page states it; a delete names the id only.
+ */
+export declare const describeBlackoutRuleWriteConfirmation: (verb: WriteVerb, { id, summary, description }: WrittenBlackoutRule) => string;
+//#endregion
+//#region src/index.d.ts
+export type ClientCapability = "versioned-api-contracts" | "shared-domain-operations" | "connectivity-and-discovery-contracts" | "automation-auth-contracts";
+export type ClientPackageContract = {
+  readonly name: "@letpeoplework/lighthouse-client";
+  readonly capabilities: readonly ClientCapability[];
+};
+export declare const getClientPackageContract: () => ClientPackageContract;
+export type ConnectivityCategory = "success" | "unreachable" | "misconfigured" | "unauthorized" | "dependency-failure" | "concurrency-conflict" | "unexpected";
+export type StandaloneDiscoveryContract = {
+  readonly contractVersion: 1;
+  readonly lighthouseUrl: string;
+  readonly detectedAtUtc: string;
+};
+export type StandaloneDiscoveryContractParseResult = {
+  readonly isValid: true;
+  readonly contract: StandaloneDiscoveryContract;
+} | {
+  readonly isValid: false;
+  readonly reason: string;
+};
+export type LighthouseConnectionConfiguration = {
+  readonly kind: "explicit";
+  readonly lighthouseUrl: string;
+} | {
+  readonly kind: "standalone";
+  readonly getDiscoveryContract: () => Promise<StandaloneDiscoveryContract | null>;
+};
+export type ConnectivityFetchResponse = {
+  readonly ok: boolean;
+  readonly status: number;
+  readonly text: () => Promise<string>;
+  readonly json?: () => Promise<unknown>;
+};
+export type ConnectivityDependencies = {
+  readonly fetch: (url: string, init?: RequestInit) => Promise<ConnectivityFetchResponse>;
+};
+export type ResolvedLighthouseEndpoint = {
+  readonly mode: "explicit" | "standalone";
+  readonly lighthouseUrl: string;
+  readonly apiBaseUrl: string;
+  readonly healthCheckUrl: string;
+};
+export type ConnectivityValidationResult = {
+  readonly category: "success";
+  readonly endpoint: ResolvedLighthouseEndpoint;
+  readonly serverVersion: string;
+} | {
+  readonly category: Exclude<ConnectivityCategory, "success">;
+  readonly reason: string;
+  readonly statusCode?: number;
+  readonly endpoint?: ResolvedLighthouseEndpoint;
+};
+export declare const parseStandaloneDiscoveryContract: (serializedContract: string) => StandaloneDiscoveryContractParseResult;
+export declare const getStandaloneDiscoveryLockfilePath: () => string;
+export declare const loadStandaloneDiscoveryContract: () => Promise<StandaloneDiscoveryContract | null>;
+export declare const validateLighthouseConnectivity: (configuration: LighthouseConnectionConfiguration, dependencies: ConnectivityDependencies, requestInit?: RequestInit) => Promise<ConnectivityValidationResult>;
+export type LighthouseClientAuth = {
+  readonly kind: "none";
+} | {
+  readonly kind: "api-key";
+  readonly value: string;
+  readonly headerName?: string;
+} | {
+  readonly kind: "bearer-token";
+  readonly token: string;
+};
+export type StoredLighthouseAuth = Exclude<LighthouseClientAuth, {
+  kind: "none";
 }>;
-type LighthouseAuthOverrides = {
-    readonly apiKey?: string;
-    readonly bearerToken?: string;
-    readonly apiKeyHeaderName?: string;
-};
-type LighthouseAuthStatus = {
-    readonly isAuthenticated: boolean;
-    readonly kind: LighthouseClientAuth["kind"];
-    readonly source: "none" | "stored" | "override";
-};
-type LighthouseAuthStore = {
-    readonly load: () => Promise<StoredLighthouseAuth | null>;
-    readonly save: (auth: StoredLighthouseAuth) => Promise<void>;
-    readonly clear: () => Promise<void>;
-};
-type LighthouseAuthContext = {
-    readonly resolveAuth: (overrides?: LighthouseAuthOverrides) => Promise<LighthouseClientAuth>;
-    readonly login: (overrides: LighthouseAuthOverrides) => Promise<void>;
-    readonly logout: () => Promise<void>;
-    readonly getStatus: (overrides?: LighthouseAuthOverrides) => Promise<LighthouseAuthStatus>;
-};
-declare const createLighthouseAuthContext: (store: LighthouseAuthStore) => LighthouseAuthContext;
-type CliServerAuthMode = "disabled" | "required" | "blocked" | "misconfigured";
-type ServerAuthModeResult = {
-    readonly mode: CliServerAuthMode;
-    readonly misconfigurationMessage?: string;
-};
-type CliAuthSessionStartResult = {
-    readonly status: "started";
-    readonly sessionId: string;
-    readonly verificationUrl: string;
-    readonly expiresAt: string;
-};
-type CliAuthSessionStartError = {
-    readonly status: "error";
-    readonly category: Exclude<ConnectivityCategory, "success">;
-    readonly reason: string;
-    readonly statusCode?: number;
-};
-type CliAuthSessionStartOutcome = CliAuthSessionStartResult | CliAuthSessionStartError;
-type CliAuthSessionPollResult = {
-    readonly status: "pending";
+export type LighthouseAuthOverrides = {
+  readonly apiKey?: string;
+  readonly bearerToken?: string;
+  readonly apiKeyHeaderName?: string;
+};
+export type LighthouseAuthStatus = {
+  readonly isAuthenticated: boolean;
+  readonly kind: LighthouseClientAuth["kind"];
+  readonly source: "none" | "stored" | "override";
+};
+export type LighthouseAuthStore = {
+  readonly load: () => Promise<StoredLighthouseAuth | null>;
+  readonly save: (auth: StoredLighthouseAuth) => Promise<void>;
+  readonly clear: () => Promise<void>;
+};
+export type LighthouseAuthContext = {
+  readonly resolveAuth: (overrides?: LighthouseAuthOverrides) => Promise<LighthouseClientAuth>;
+  readonly login: (overrides: LighthouseAuthOverrides) => Promise<void>;
+  readonly logout: () => Promise<void>;
+  readonly getStatus: (overrides?: LighthouseAuthOverrides) => Promise<LighthouseAuthStatus>;
+};
+export declare const createLighthouseAuthContext: (store: LighthouseAuthStore) => LighthouseAuthContext;
+export type CliServerAuthMode = "disabled" | "required" | "blocked" | "misconfigured";
+export type ServerAuthModeResult = {
+  readonly mode: CliServerAuthMode;
+  readonly misconfigurationMessage?: string;
+};
+export type CliAuthSessionStartResult = {
+  readonly status: "started";
+  readonly sessionId: string;
+  readonly verificationUrl: string;
+  readonly expiresAt: string;
+};
+export type CliAuthSessionStartError = {
+  readonly status: "error";
+  readonly category: Exclude<ConnectivityCategory, "success">;
+  readonly reason: string;
+  readonly statusCode?: number;
+};
+export type CliAuthSessionStartOutcome = CliAuthSessionStartResult | CliAuthSessionStartError;
+export type CliAuthSessionPollResult = {
+  readonly status: "pending";
 } | {
-    readonly status: "approved";
-    readonly token: string;
-    readonly userName: string;
+  readonly status: "approved";
+  readonly token: string;
+  readonly userName: string;
 } | {
-    readonly status: "expired";
+  readonly status: "expired";
 } | {
-    readonly status: "denied";
+  readonly status: "denied";
 } | {
-    readonly status: "not-found";
+  readonly status: "not-found";
 };
-type CliServerConnection = {
-    readonly mode: "server";
-    readonly endpointUrl: string;
-    readonly authMode: "disabled" | "required";
-    readonly insecure?: boolean;
-    readonly auth?: StoredLighthouseAuth;
+export type CliServerConnection = {
+  readonly mode: "server";
+  readonly endpointUrl: string;
+  readonly authMode: "disabled" | "required";
+  readonly insecure?: boolean;
+  readonly auth?: StoredLighthouseAuth;
 };
-type CliStandaloneConnection = {
-    readonly mode: "standalone";
-    readonly authMode: "disabled";
+export type CliStandaloneConnection = {
+  readonly mode: "standalone";
+  readonly authMode: "disabled";
 };
-type CliConnection = CliServerConnection | CliStandaloneConnection;
+export type CliConnection = CliServerConnection | CliStandaloneConnection;
 type CliAuthDependencies = {
-    readonly fetch: typeof globalThis.fetch;
-};
-declare const queryServerAuthMode: (endpointUrl: string, dependencies: CliAuthDependencies) => Promise<ServerAuthModeResult>;
-declare const startCliAuthSession: (endpointUrl: string, dependencies: CliAuthDependencies) => Promise<CliAuthSessionStartOutcome>;
-declare const pollCliAuthSession: (endpointUrl: string, sessionId: string, dependencies: CliAuthDependencies) => Promise<CliAuthSessionPollResult>;
-type LighthouseClientConfiguration = {
-    readonly connection: LighthouseConnectionConfiguration;
-    readonly auth?: LighthouseClientAuth;
-};
-type LighthouseApiError = {
-    readonly category: ConnectivityCategory;
-    readonly reason: string;
-    readonly statusCode?: number;
-};
-type LighthouseApiResult<TValue> = {
-    readonly ok: true;
-    readonly value: TValue;
+  readonly fetch: typeof globalThis.fetch;
+};
+export declare const queryServerAuthMode: (endpointUrl: string, dependencies: CliAuthDependencies) => Promise<ServerAuthModeResult>;
+export declare const startCliAuthSession: (endpointUrl: string, dependencies: CliAuthDependencies) => Promise<CliAuthSessionStartOutcome>;
+export declare const pollCliAuthSession: (endpointUrl: string, sessionId: string, dependencies: CliAuthDependencies) => Promise<CliAuthSessionPollResult>;
+export type LighthouseClientConfiguration = {
+  readonly connection: LighthouseConnectionConfiguration;
+  readonly auth?: LighthouseClientAuth;
+};
+export type LighthouseApiError = {
+  readonly category: ConnectivityCategory;
+  readonly reason: string;
+  readonly statusCode?: number;
+  /** The `code` a refusal names, so a surface can put it into its own words. */
+  readonly problemCode?: string;
+  /** The refusal's title as Lighthouse states it. */
+  readonly problemTitle?: string;
+};
+export type LighthouseApiResult<TValue> = {
+  readonly ok: true;
+  readonly value: TValue;
 } | {
-    readonly ok: false;
-    readonly error: LighthouseApiError;
-};
-type LighthouseWritePayload = Readonly<Record<string, unknown>>;
-type MetricsDateRange = {
-    readonly startDate: string;
-    readonly endDate: string;
-};
-declare const getDefaultMetricsDateRange: () => MetricsDateRange;
-type ManualForecastInput = {
-    readonly remainingItems?: number;
-    readonly targetDate?: string;
-    /**
-     * Override the team's forecast-filter setting for this forecast call:
-     * - `true`  — apply the team's exclusion rule (filtered throughput).
-     * - `false` — skip the team's exclusion rule (raw throughput).
-     * - omit    — respect the team's current setting (default).
-     *
-     * Lighthouse v26.5.24.10+. Older servers ignore this field.
-     */
-    readonly applyFilterOverride?: boolean;
-};
-type BacktestInput = {
-    readonly startDate: string;
-    readonly endDate: string;
-    readonly historicalStartDate: string;
-    readonly historicalEndDate: string;
-    /**
-     * Override the team's forecast-filter setting for this backtest call:
-     * - `true`  — apply the team's exclusion rule (filtered throughput).
-     * - `false` — skip the team's exclusion rule (raw throughput).
-     * - omit    — respect the team's current setting (default).
-     *
-     * Lighthouse v26.5.24.10+. Older servers ignore this field.
-     */
-    readonly applyFilterOverride?: boolean;
+  readonly ok: false;
+  readonly error: LighthouseApiError;
+};
+export type LighthouseWritePayload = Readonly<Record<string, unknown>>;
+export type MetricsDateRange = {
+  readonly startDate: string;
+  readonly endDate: string;
+};
+export declare const getDefaultMetricsDateRange: () => MetricsDateRange;
+export type ManualForecastInput = {
+  readonly remainingItems?: number;
+  readonly targetDate?: string;
+  /**
+   * Override the team's forecast-filter setting for this forecast call:
+   * - `true`  — apply the team's exclusion rule (filtered throughput).
+   * - `false` — skip the team's exclusion rule (raw throughput).
+   * - omit    — respect the team's current setting (default).
+   *
+   * Lighthouse v26.5.24.10+. Older servers ignore this field.
+   */
+  readonly applyFilterOverride?: boolean;
+};
+export type BacktestInput = {
+  readonly startDate: string;
+  readonly endDate: string;
+  readonly historicalStartDate: string;
+  readonly historicalEndDate: string;
+  /**
+   * Override the team's forecast-filter setting for this backtest call:
+   * - `true`  — apply the team's exclusion rule (filtered throughput).
+   * - `false` — skip the team's exclusion rule (raw throughput).
+   * - omit    — respect the team's current setting (default).
+   *
+   * Lighthouse v26.5.24.10+. Older servers ignore this field.
+   */
+  readonly applyFilterOverride?: boolean;
 };
 /**
  * Forecast-filter view for team-level throughput / PBC / predictability metrics.
@@ -193,31 +1342,31 @@ type BacktestInput = {
  * - `"filtered"` — apply the team's exclusion rule.
  * - `"raw"` / omit — return unfiltered data (default).
  */
-type ThroughputFilterView = "raw" | "filtered";
-type WorkItemAgeEntry = {
-    readonly id: number;
-    readonly name: string;
-    readonly referenceId: string;
-    readonly age: number;
+export type ThroughputFilterView = "raw" | "filtered";
+export type WorkItemAgeEntry = {
+  readonly id: number;
+  readonly name: string;
+  readonly referenceId: string;
+  readonly age: number;
 };
-type DailyWorkItemAge = {
-    readonly date: string;
-    readonly items: readonly WorkItemAgeEntry[];
+export type DailyWorkItemAge = {
+  readonly date: string;
+  readonly items: readonly WorkItemAgeEntry[];
 };
-type DailyTotalWorkItemAge = {
-    readonly date: string;
-    readonly totalAge: number;
-    readonly itemCount: number;
+export type DailyTotalWorkItemAge = {
+  readonly date: string;
+  readonly totalAge: number;
+  readonly itemCount: number;
 };
-type WorkItemAgeOverTimeResult = {
-    readonly startDate: string;
-    readonly endDate: string;
-    readonly daily: readonly DailyWorkItemAge[];
+export type WorkItemAgeOverTimeResult = {
+  readonly startDate: string;
+  readonly endDate: string;
+  readonly daily: readonly DailyWorkItemAge[];
 };
-type TotalWorkItemAgeOverTimeResult = {
-    readonly startDate: string;
-    readonly endDate: string;
-    readonly daily: readonly DailyTotalWorkItemAge[];
+export type TotalWorkItemAgeOverTimeResult = {
+  readonly startDate: string;
+  readonly endDate: string;
+  readonly daily: readonly DailyTotalWorkItemAge[];
 };
 /**
  * One captured point on the blocked-items-over-time trend: how many items were
@@ -229,9 +1378,9 @@ type TotalWorkItemAgeOverTimeResult = {
  * newer than v26.7.3.1 each WIP work item carries `isBlocked` and, when blocked,
  * a `blockedSince` timestamp.
  */
-type BlockedCountSnapshot = {
-    readonly recordedAt: string;
-    readonly blockedCount: number;
+export type BlockedCountSnapshot = {
+  readonly recordedAt: string;
+  readonly blockedCount: number;
 };
 /**
  * One epic as it stood on the day a delivery snapshot was taken.
@@ -240,37 +1389,37 @@ type BlockedCountSnapshot = {
  * `isUsingDefaultSize` are absent from every snapshot recorded before Lighthouse began writing
  * sizes, so both are optional and a missing value means "not recorded", never zero.
  */
-type DeliveryFeatureMetric = {
-    readonly referenceId: string;
-    readonly name: string;
-    readonly completion: number;
-    readonly likelihood: number | null;
-    readonly totalItems?: number | null;
-    readonly isUsingDefaultSize?: boolean | null;
+export type DeliveryFeatureMetric = {
+  readonly referenceId: string;
+  readonly name: string;
+  readonly completion: number;
+  readonly likelihood: number | null;
+  readonly totalItems?: number | null;
+  readonly isUsingDefaultSize?: boolean | null;
 };
 /** One point on a delivery's forecast distribution: the chance of finishing by a date. */
-type DeliveryWhenDistributionPoint = {
-    readonly probability: number;
-    readonly expectedDate: string;
+export type DeliveryWhenDistributionPoint = {
+  readonly probability: number;
+  readonly expectedDate: string;
 };
 /** A delivery as it stood on one recorded day. Dates are ISO strings. */
-type DeliveryMetricsHistoryPoint = {
-    readonly date: string;
-    readonly targetDateAtSnapshot: string | null;
-    readonly totalWork: number;
-    readonly doneWork: number;
-    readonly remainingWork: number;
-    readonly estimatedItemCount: number | null;
-    readonly forecastHowMany: number | null;
-    readonly likelihoodPercentage: number | null;
-    readonly whenDistribution: readonly DeliveryWhenDistributionPoint[] | null;
-    readonly featureBreakdown: readonly DeliveryFeatureMetric[];
+export type DeliveryMetricsHistoryPoint = {
+  readonly date: string;
+  readonly targetDateAtSnapshot: string | null;
+  readonly totalWork: number;
+  readonly doneWork: number;
+  readonly remainingWork: number;
+  readonly estimatedItemCount: number | null;
+  readonly forecastHowMany: number | null;
+  readonly likelihoodPercentage: number | null;
+  readonly whenDistribution: readonly DeliveryWhenDistributionPoint[] | null;
+  readonly featureBreakdown: readonly DeliveryFeatureMetric[];
 };
 /** The whole recorded trend for one delivery. Forward-only: it starts at the first snapshot. */
-type DeliveryMetricsHistory = {
-    readonly deliveryDate: string;
-    readonly firstSnapshotDate: string | null;
-    readonly points: readonly DeliveryMetricsHistoryPoint[];
+export type DeliveryMetricsHistory = {
+  readonly deliveryDate: string;
+  readonly firstSnapshotDate: string | null;
+  readonly points: readonly DeliveryMetricsHistoryPoint[];
 };
 /**
  * One day of a delivery, without the per-epic breakdown or the forecast distribution.
@@ -279,14 +1428,14 @@ type DeliveryMetricsHistory = {
  * distribution per day — more than an assistant should be handed by default (ADR-121), and more
  * than a terminal can show. {@link summariseDeliveryMetricsHistory} projects to this.
  */
-type DeliveryMetricsHistorySummaryRow = {
-    readonly date: string;
-    readonly totalWork: number;
-    readonly doneWork: number;
-    readonly remainingWork: number;
-    readonly epicCount: number;
-    readonly estimatedItemCount: number | null;
-    readonly likelihoodPercentage: number | null;
+export type DeliveryMetricsHistorySummaryRow = {
+  readonly date: string;
+  readonly totalWork: number;
+  readonly doneWork: number;
+  readonly remainingWork: number;
+  readonly epicCount: number;
+  readonly estimatedItemCount: number | null;
+  readonly likelihoodPercentage: number | null;
 };
 /**
  * Projects a delivery history to one row per recorded day. Pure.
@@ -294,12 +1443,12 @@ type DeliveryMetricsHistorySummaryRow = {
  * The client itself returns the payload whole: dropping data is the caller's choice, so the CLI and
  * the MCP tool apply this by default and step around it when asked for per-epic detail.
  */
-declare const summariseDeliveryMetricsHistory: (history: DeliveryMetricsHistory) => readonly DeliveryMetricsHistorySummaryRow[];
+export declare const summariseDeliveryMetricsHistory: (history: DeliveryMetricsHistory) => readonly DeliveryMetricsHistorySummaryRow[];
 /**
  * Percentile family recorded by the percentiles-over-time pipeline. Sent as the
  * `metricType` query parameter, and echoed back on every returned row.
  */
-type PercentilesOverTimeMetricType = "CycleTime" | "WorkItemAge";
+export type PercentilesOverTimeMetricType = "CycleTime" | "WorkItemAge";
 /**
  * One captured day on the percentiles-over-time trend: the percentile quartet
  * recorded for {@link recordedAt} (an ISO date string, one row per calendar day,
@@ -320,13 +1469,13 @@ type PercentilesOverTimeMetricType = "CycleTime" | "WorkItemAge";
  * shape carries no horizon field they cannot be told apart. Pass an explicit
  * horizon whenever you ask for `CycleTime`.
  */
-type PercentilesOverTimeSnapshot = {
-    readonly recordedAt: string;
-    readonly metricType: PercentilesOverTimeMetricType;
-    readonly p50: number;
-    readonly p70: number;
-    readonly p85: number;
-    readonly p95: number;
+export type PercentilesOverTimeSnapshot = {
+  readonly recordedAt: string;
+  readonly metricType: PercentilesOverTimeMetricType;
+  readonly p50: number;
+  readonly p70: number;
+  readonly p85: number;
+  readonly p95: number;
 };
 /**
  * Process-behaviour family recorded by the natural-process-limits over-time
@@ -336,7 +1485,7 @@ type PercentilesOverTimeSnapshot = {
  * never records it. The server answers a team asking for it with an empty
  * series rather than an error.
  */
-type ProcessBehaviorMetricType = "Throughput" | "WorkItemAge" | "Wip" | "CycleTime" | "Arrivals" | "FeatureSize";
+export type ProcessBehaviorMetricType = "Throughput" | "WorkItemAge" | "Wip" | "CycleTime" | "Arrivals" | "FeatureSize";
 /**
  * One captured day on the process-behaviour-over-time trend: the natural process
  * limit triple recorded for {@link recordedAt} (an ISO date string, one row per
@@ -350,140 +1499,307 @@ type ProcessBehaviorMetricType = "Throughput" | "WorkItemAge" | "Wip" | "CycleTi
  * series rather than present as a zeroed triple, so an empty array means
  * "nothing recorded yet", never "a process pinned at zero".
  */
-type ProcessBehaviorSnapshot = {
-    readonly recordedAt: string;
-    readonly unpl: number;
-    readonly average: number;
-    readonly lnpl: number;
-};
-type CumulativeStateTimeStateRow = {
-    readonly state: string;
-    readonly workflowOrder: number;
-    readonly totalDays: number;
-    readonly completedContributionDays: number;
-    readonly ongoingContributionDays: number;
-    readonly itemCount: number;
-    readonly completedItemCount: number;
-    readonly ongoingItemCount: number;
-    readonly meanDays: number;
-    readonly medianDays: number | null;
-};
-type CumulativeStateTimeResult = {
-    readonly states: readonly CumulativeStateTimeStateRow[];
-};
-type CumulativeStateTimeItemRow = {
-    readonly workItemId: number;
-    readonly referenceId: string;
-    readonly title: string;
-    readonly type: string;
-    readonly state: string;
-    readonly stateCategory: string;
-    readonly url: string | null;
-    readonly daysContributed: number;
-};
-type CumulativeStateTimeItemsResult = {
-    readonly state: string;
-    readonly items: readonly CumulativeStateTimeItemRow[];
-};
-type CumulativeStateTimeCandidateRow = {
-    readonly workItemId: number;
-    readonly referenceId: string;
-    readonly title: string;
-    readonly workItemType: string;
-};
-type CumulativeStateTimeCandidatesResult = {
-    readonly items: readonly CumulativeStateTimeCandidateRow[];
-};
-type DayOfWeek = "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday";
-type RecurringBlackoutRule = {
-    readonly id: number;
-    readonly weekdays: readonly DayOfWeek[];
-    readonly intervalWeeks: number;
-    readonly start: string;
-    readonly end: string | null;
-    readonly description: string;
-    readonly summary: string;
-};
-type RecurringBlackoutRuleInput = {
-    readonly weekdays: readonly DayOfWeek[];
-    readonly intervalWeeks: number;
-    readonly start: string;
-    readonly end: string | null;
-    readonly description: string;
-};
-type LighthouseClient = {
-    readonly checkConnectivity: () => Promise<ConnectivityValidationResult>;
-    readonly getVersion: () => Promise<LighthouseApiResult<string>>;
-    readonly listWorkTrackingConnections: () => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getWorkTrackingConnection: (connectionId: number) => Promise<LighthouseApiResult<unknown>>;
-    readonly createWorkTrackingConnection: (payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
-    readonly updateWorkTrackingConnection: (connectionId: number, payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
-    readonly deleteWorkTrackingConnection: (connectionId: number) => Promise<LighthouseApiResult<void>>;
-    readonly listTeams: () => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getTeam: (teamId: number) => Promise<LighthouseApiResult<unknown>>;
-    readonly createTeam: (payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
-    readonly updateTeam: (teamId: number, payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
-    readonly deleteTeam: (teamId: number) => Promise<LighthouseApiResult<void>>;
-    readonly refreshTeam: (teamId: number) => Promise<LighthouseApiResult<void>>;
-    readonly listPortfolios: () => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getPortfolio: (portfolioId: number) => Promise<LighthouseApiResult<unknown>>;
-    readonly createPortfolio: (payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
-    readonly updatePortfolio: (portfolioId: number, payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
-    readonly deletePortfolio: (portfolioId: number) => Promise<LighthouseApiResult<void>>;
-    readonly refreshPortfolio: (portfolioId: number) => Promise<LighthouseApiResult<void>>;
-    readonly getTeamThroughput: (teamId: number, range?: MetricsDateRange, view?: ThroughputFilterView) => Promise<LighthouseApiResult<unknown>>;
-    readonly getTeamArrivals: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
-    readonly getTeamWipOverTime: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
-    readonly getTeamWip: (teamId: number, asOfDate: string) => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getTeamCycleTimePercentiles: (teamId: number, range?: MetricsDateRange, definitionId?: number) => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getTeamWorkItemAgePercentiles: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getTeamCycleTimeData: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getTeamPredictabilityScore: (teamId: number, range?: MetricsDateRange, view?: ThroughputFilterView) => Promise<LighthouseApiResult<unknown>>;
-    readonly getTeamTotalWorkItemAge: (teamId: number, asOfDate: string) => Promise<LighthouseApiResult<number>>;
-    readonly getTeamTotalWorkItemAgeInfo: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
-    readonly getPortfolioThroughput: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
-    readonly getPortfolioCycleTimePercentiles: (portfolioId: number, range?: MetricsDateRange, definitionId?: number) => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getPortfolioWorkItemAgePercentiles: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getPortfolioArrivals: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
-    readonly getPortfolioWipOverTime: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
-    readonly getPortfolioWip: (portfolioId: number, asOfDate: string) => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getPortfolioCycleTimeData: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getPortfolioPredictabilityScore: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
-    readonly getTeamWorkItemAgeOverTime: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<WorkItemAgeOverTimeResult>>;
-    readonly getTeamTotalWorkItemAgeOverTime: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<TotalWorkItemAgeOverTimeResult>>;
-    readonly getPortfolioTotalWorkItemAge: (portfolioId: number, asOfDate: string) => Promise<LighthouseApiResult<number>>;
-    readonly getPortfolioTotalWorkItemAgeInfo: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
-    readonly getPortfolioWorkItemAgeOverTime: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<WorkItemAgeOverTimeResult>>;
-    readonly getPortfolioTotalWorkItemAgeOverTime: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<TotalWorkItemAgeOverTimeResult>>;
-    readonly getTeamBlockedCountHistory: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<readonly BlockedCountSnapshot[]>>;
-    readonly getPortfolioBlockedCountHistory: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<readonly BlockedCountSnapshot[]>>;
-    readonly getTeamPercentilesOverTime: (teamId: number, range?: MetricsDateRange, metricType?: PercentilesOverTimeMetricType, horizon?: number) => Promise<LighthouseApiResult<readonly PercentilesOverTimeSnapshot[]>>;
-    readonly getPortfolioPercentilesOverTime: (portfolioId: number, range?: MetricsDateRange, metricType?: PercentilesOverTimeMetricType, horizon?: number) => Promise<LighthouseApiResult<readonly PercentilesOverTimeSnapshot[]>>;
-    readonly getTeamProcessBehaviorOverTime: (teamId: number, range?: MetricsDateRange, metricType?: ProcessBehaviorMetricType) => Promise<LighthouseApiResult<readonly ProcessBehaviorSnapshot[]>>;
-    readonly getPortfolioProcessBehaviorOverTime: (portfolioId: number, range?: MetricsDateRange, metricType?: ProcessBehaviorMetricType) => Promise<LighthouseApiResult<readonly ProcessBehaviorSnapshot[]>>;
-    readonly getTeamCumulativeStateTime: (teamId: number, range?: MetricsDateRange, itemIds?: readonly number[]) => Promise<LighthouseApiResult<CumulativeStateTimeResult>>;
-    readonly getTeamCumulativeStateTimeItems: (teamId: number, state: string, range?: MetricsDateRange, itemIds?: readonly number[]) => Promise<LighthouseApiResult<CumulativeStateTimeItemsResult>>;
-    readonly getTeamCumulativeStateTimeCandidates: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<CumulativeStateTimeCandidatesResult>>;
-    readonly getPortfolioCumulativeStateTime: (portfolioId: number, range?: MetricsDateRange, itemIds?: readonly number[]) => Promise<LighthouseApiResult<CumulativeStateTimeResult>>;
-    readonly getPortfolioCumulativeStateTimeItems: (portfolioId: number, state: string, range?: MetricsDateRange, itemIds?: readonly number[]) => Promise<LighthouseApiResult<CumulativeStateTimeItemsResult>>;
-    readonly getPortfolioCumulativeStateTimeCandidates: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<CumulativeStateTimeCandidatesResult>>;
-    readonly getFeaturesByIds: (ids: readonly number[]) => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getFeaturesByReferences: (refs: readonly string[]) => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly getFeatureWorkItems: (featureId: number) => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly listDeliveries: (portfolioId: number) => Promise<LighthouseApiResult<readonly unknown[]>>;
-    readonly createDelivery: (portfolioId: number, payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
-    readonly updateDelivery: (deliveryId: number, payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
-    readonly deleteDelivery: (deliveryId: number) => Promise<LighthouseApiResult<undefined>>;
-    readonly getDeliveryMetricsHistory: (deliveryId: number) => Promise<LighthouseApiResult<DeliveryMetricsHistory>>;
-    readonly getRecurringBlackoutRules: () => Promise<LighthouseApiResult<readonly RecurringBlackoutRule[]>>;
-    readonly createRecurringBlackoutRule: (payload: LighthouseWritePayload) => Promise<LighthouseApiResult<RecurringBlackoutRule>>;
-    readonly updateRecurringBlackoutRule: (id: number, payload: LighthouseWritePayload) => Promise<LighthouseApiResult<RecurringBlackoutRule>>;
-    readonly deleteRecurringBlackoutRule: (id: number) => Promise<LighthouseApiResult<undefined>>;
-    readonly runManualForecast: (teamId: number, payload: ManualForecastInput) => Promise<LighthouseApiResult<unknown>>;
-    readonly runBacktest: (teamId: number, payload: BacktestInput) => Promise<LighthouseApiResult<unknown>>;
-};
-type LighthouseClientDependencies = {
-    readonly fetch?: (url: string, init?: RequestInit) => Promise<ConnectivityFetchResponse>;
+export type ProcessBehaviorSnapshot = {
+  readonly recordedAt: string;
+  readonly unpl: number;
+  readonly average: number;
+  readonly lnpl: number;
+};
+/** The chart types a Team has a Process Behaviour Chart for; Feature Size is charted for Portfolios only. */
+export type TeamProcessBehaviorMetricType = Exclude<ProcessBehaviorMetricType, "FeatureSize">;
+/** One day on a Process Behaviour Chart, with the signals Lighthouse found on it by name. */
+export type ProcessBehaviorChartDataPoint = {
+  readonly xValue: string;
+  readonly yValue: number;
+  readonly specialCauses: readonly string[];
+  readonly workItemIds: readonly number[];
+  readonly isBlackout?: boolean;
+};
+/**
+ * A Process Behaviour Chart as Lighthouse computes it: its limits, why it could not be computed when its
+ * status is not Ready, and every day with the signals found on it. An older Lighthouse leaves out the
+ * baseline flag and the blackout days.
+ */
+export type ProcessBehaviorChart = {
+  readonly status: string;
+  readonly statusReason: string;
+  readonly xAxisKind: string;
+  readonly average: number;
+  readonly upperNaturalProcessLimit: number;
+  readonly lowerNaturalProcessLimit: number;
+  readonly baselineConfigured?: boolean;
+  readonly dataPoints: readonly ProcessBehaviorChartDataPoint[];
+};
+/**
+ * One Work Item in progress and the chance it misses its Team's SLE, in percent. The miss count is
+ * null when the Work Item is already past the SLE: that settles it without looking at any history.
+ */
+export type SleRiskEntry = {
+  readonly referenceId: string;
+  readonly risk: number;
+  readonly finishedItemsStillOpenAtThisAge: number;
+  readonly finishedItemsThatWentOnToMiss: number | null;
+};
+export type CumulativeStateTimeStateRow = {
+  readonly state: string;
+  readonly workflowOrder: number;
+  readonly totalDays: number;
+  readonly completedContributionDays: number;
+  readonly ongoingContributionDays: number;
+  readonly itemCount: number;
+  readonly completedItemCount: number;
+  readonly ongoingItemCount: number;
+  readonly meanDays: number;
+  readonly medianDays: number | null;
+};
+export type CumulativeStateTimeResult = {
+  readonly states: readonly CumulativeStateTimeStateRow[];
+};
+export type CumulativeStateTimeItemRow = {
+  readonly workItemId: number;
+  readonly referenceId: string;
+  readonly title: string;
+  readonly type: string;
+  readonly state: string;
+  readonly stateCategory: string;
+  readonly url: string | null;
+  readonly daysContributed: number;
+};
+export type CumulativeStateTimeItemsResult = {
+  readonly state: string;
+  readonly items: readonly CumulativeStateTimeItemRow[];
+};
+export type CumulativeStateTimeCandidateRow = {
+  readonly workItemId: number;
+  readonly referenceId: string;
+  readonly title: string;
+  readonly workItemType: string;
+};
+export type CumulativeStateTimeCandidatesResult = {
+  readonly items: readonly CumulativeStateTimeCandidateRow[];
+};
+export type DayOfWeek = "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday";
+export type RecurringBlackoutRule = {
+  readonly id: number;
+  readonly weekdays: readonly DayOfWeek[];
+  readonly intervalWeeks: number;
+  readonly start: string;
+  readonly end: string | null;
+  readonly description: string;
+  readonly summary: string;
+};
+export type RecurringBlackoutRuleInput = {
+  readonly weekdays: readonly DayOfWeek[];
+  readonly intervalWeeks: number;
+  readonly start: string;
+  readonly end: string | null;
+  readonly description: string;
+};
+export type RefinementVerdict = "Below" | "In" | "Above";
+export type NeedUnavailableReason = "NoCadence" | "InsufficientData" | "NoRefinementStates";
+export type RefinementNeed = {
+  readonly verdict: RefinementVerdict | null;
+  readonly unavailableReason: NeedUnavailableReason | null;
+  readonly low: number | null;
+  readonly high: number | null;
+  readonly lowPercentile: number | null;
+  readonly highPercentile: number | null;
+  readonly horizonWorkingDays: number | null;
+  readonly cycleStart: string | null;
+  readonly cycleEnd: string | null;
+};
+export type RefinementRow = {
+  readonly referenceId: string;
+  readonly name: string;
+  readonly url: string | null;
+  readonly state: string;
+  readonly parentReferenceId: string;
+  readonly voteCount: number;
+  readonly myVote: RefinementAnswer | null;
+  readonly split: {
+    readonly yes: number;
+    readonly yesBut: number;
+    readonly no: number;
+  };
+  readonly readiness: "Ready" | "MoreYesNeeded" | "MoreVotersNeeded" | "NeedsDiscussion";
+  readonly missingVotes: number | null;
+  readonly stage: "Waiting" | "BeingRefined" | "Ready" | null;
+  readonly signalsDisagree: boolean;
+  readonly hasComments: boolean;
+  readonly hasOpenQuestion: boolean;
+};
+/** The answers a vote can give, in the order the web's buttons show them. */
+export declare const REFINEMENT_ANSWERS: readonly ["Yes", "YesBut", "No"];
+export type RefinementAnswer = (typeof REFINEMENT_ANSWERS)[number];
+export declare const isRefinementAnswer: (value: unknown) => value is RefinementAnswer;
+/** Where a vote, comment or take-back was sent from. */
+export type RefinementChannel = "Cli" | "Assistant";
+/** A Work Item in refinement as a vote, comment or take-back left it. */
+export type VotedRow = RefinementRow & {
+  readonly madeReady: boolean;
+};
+export type RefinementReadOptions = {
+  readonly voterKey?: string;
+};
+export type RefinementVoteInput = {
+  readonly answer: RefinementAnswer;
+  readonly channel: RefinementChannel;
+  readonly comment?: string;
+  readonly voterName?: string;
+  readonly voterKey?: string;
+};
+export type RefinementCommentInput = {
+  readonly comment: string;
+  readonly channel: RefinementChannel;
+  readonly voterName?: string;
+  readonly voterKey?: string;
+};
+export type RefinementTakeBackInput = {
+  readonly channel: RefinementChannel;
+  readonly voterKey?: string;
+  /** The answer the caller saw as theirs, so a vote changed since in another session is left standing. */
+  readonly answer?: RefinementAnswer;
+};
+/** One line of a Work Item's sizing log, oldest first; `isMine` marks the reader's own. */
+export type SizingLogEntry = {
+  readonly kind: "Vote" | "Comment" | "Revocation";
+  readonly answer: RefinementAnswer | null;
+  readonly comment: string | null;
+  readonly voterName: string;
+  readonly channel: string;
+  readonly recordedAt: string;
+  readonly isMine: boolean;
+  readonly isOpenQuestion: boolean;
+};
+export type SizingLog = {
+  readonly entries: readonly SizingLogEntry[];
+  readonly voters: {
+    readonly yes: readonly string[];
+    readonly yesBut: readonly string[];
+    readonly no: readonly string[];
+  };
+};
+export type TeamRefinement = {
+  readonly refinementConfigured: boolean;
+  readonly workItems: readonly RefinementRow[];
+  readonly yardstick: {
+    readonly source: "Sle" | "CycleTimeFallback" | "Unavailable";
+    readonly days: number | null;
+    readonly probability: number | null;
+  };
+  readonly voterIdentity: "Account" | "SelfDeclared";
+  readonly readyByVotesCount: number;
+  readonly stagesConfigured: boolean;
+  readonly readyCount: number;
+  readonly readySource: "Votes" | "Stages";
+  readonly nextRefinementDate: string | null;
+  readonly isRefinementDay: boolean;
+  readonly daysUntilNextRefinement: number | null;
+  readonly need: RefinementNeed;
+};
+export type TerminologyEntry = {
+  readonly id: number;
+  readonly key: string;
+  readonly description: string;
+  readonly defaultValue: string;
+  readonly value: string;
+};
+export type LighthouseClient = {
+  readonly checkConnectivity: () => Promise<ConnectivityValidationResult>;
+  readonly getVersion: () => Promise<LighthouseApiResult<string>>;
+  readonly listWorkTrackingConnections: () => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getWorkTrackingConnection: (connectionId: number) => Promise<LighthouseApiResult<unknown>>;
+  readonly createWorkTrackingConnection: (payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
+  readonly updateWorkTrackingConnection: (connectionId: number, payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
+  readonly deleteWorkTrackingConnection: (connectionId: number) => Promise<LighthouseApiResult<void>>;
+  readonly listTeams: () => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getTeam: (teamId: number) => Promise<LighthouseApiResult<unknown>>;
+  readonly getTeamSettings: (teamId: number) => Promise<LighthouseApiResult<unknown>>;
+  readonly createTeam: (payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
+  readonly updateTeam: (teamId: number, payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
+  readonly deleteTeam: (teamId: number) => Promise<LighthouseApiResult<void>>;
+  readonly refreshTeam: (teamId: number) => Promise<LighthouseApiResult<void>>;
+  readonly getTeamRefinement: (teamId: number, options?: RefinementReadOptions) => Promise<LighthouseApiResult<TeamRefinement>>;
+  readonly castRefinementVote: (teamId: number, workItem: string, vote: RefinementVoteInput) => Promise<LighthouseApiResult<VotedRow>>;
+  readonly addRefinementComment: (teamId: number, workItem: string, comment: RefinementCommentInput) => Promise<LighthouseApiResult<VotedRow>>;
+  readonly takeBackRefinementVote: (teamId: number, workItem: string, takeBack: RefinementTakeBackInput) => Promise<LighthouseApiResult<VotedRow>>;
+  readonly getRefinementLog: (teamId: number, workItem: string, options?: RefinementReadOptions) => Promise<LighthouseApiResult<SizingLog>>;
+  readonly getTerminology: () => Promise<LighthouseApiResult<readonly TerminologyEntry[]>>;
+  readonly listPortfolios: () => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getPortfolio: (portfolioId: number) => Promise<LighthouseApiResult<unknown>>;
+  readonly createPortfolio: (payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
+  readonly updatePortfolio: (portfolioId: number, payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
+  readonly deletePortfolio: (portfolioId: number) => Promise<LighthouseApiResult<void>>;
+  readonly refreshPortfolio: (portfolioId: number) => Promise<LighthouseApiResult<void>>;
+  readonly getTeamThroughput: (teamId: number, range?: MetricsDateRange, view?: ThroughputFilterView) => Promise<LighthouseApiResult<unknown>>;
+  readonly getTeamArrivals: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
+  readonly getTeamWipOverTime: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
+  readonly getTeamWip: (teamId: number, asOfDate: string) => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getTeamCycleTimePercentiles: (teamId: number, range?: MetricsDateRange, definitionId?: number) => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getTeamWorkItemAgePercentiles: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getTeamCycleTimeData: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getTeamPredictabilityScore: (teamId: number, range?: MetricsDateRange, view?: ThroughputFilterView) => Promise<LighthouseApiResult<unknown>>;
+  readonly getTeamTotalWorkItemAge: (teamId: number, asOfDate: string) => Promise<LighthouseApiResult<number>>;
+  readonly getTeamTotalWorkItemAgeInfo: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
+  readonly getPortfolioThroughput: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
+  readonly getPortfolioCycleTimePercentiles: (portfolioId: number, range?: MetricsDateRange, definitionId?: number) => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getPortfolioWorkItemAgePercentiles: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getPortfolioArrivals: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
+  readonly getPortfolioWipOverTime: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
+  readonly getPortfolioWip: (portfolioId: number, asOfDate: string) => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getPortfolioCycleTimeData: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getPortfolioPredictabilityScore: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
+  readonly getTeamWorkItemAgeOverTime: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<WorkItemAgeOverTimeResult>>;
+  readonly getTeamTotalWorkItemAgeOverTime: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<TotalWorkItemAgeOverTimeResult>>;
+  readonly getPortfolioTotalWorkItemAge: (portfolioId: number, asOfDate: string) => Promise<LighthouseApiResult<number>>;
+  readonly getPortfolioTotalWorkItemAgeInfo: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<unknown>>;
+  readonly getPortfolioWorkItemAgeOverTime: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<WorkItemAgeOverTimeResult>>;
+  readonly getPortfolioTotalWorkItemAgeOverTime: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<TotalWorkItemAgeOverTimeResult>>;
+  readonly getTeamBlockedCountHistory: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<readonly BlockedCountSnapshot[]>>;
+  readonly getPortfolioBlockedCountHistory: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<readonly BlockedCountSnapshot[]>>;
+  readonly getTeamPercentilesOverTime: (teamId: number, range?: MetricsDateRange, metricType?: PercentilesOverTimeMetricType, horizon?: number) => Promise<LighthouseApiResult<readonly PercentilesOverTimeSnapshot[]>>;
+  readonly getPortfolioPercentilesOverTime: (portfolioId: number, range?: MetricsDateRange, metricType?: PercentilesOverTimeMetricType, horizon?: number) => Promise<LighthouseApiResult<readonly PercentilesOverTimeSnapshot[]>>;
+  readonly getTeamProcessBehaviorOverTime: (teamId: number, range?: MetricsDateRange, metricType?: ProcessBehaviorMetricType) => Promise<LighthouseApiResult<readonly ProcessBehaviorSnapshot[]>>;
+  readonly getPortfolioProcessBehaviorOverTime: (portfolioId: number, range?: MetricsDateRange, metricType?: ProcessBehaviorMetricType) => Promise<LighthouseApiResult<readonly ProcessBehaviorSnapshot[]>>;
+  readonly getTeamProcessBehaviorChart: (teamId: number, range: MetricsDateRange | undefined, metricType: TeamProcessBehaviorMetricType) => Promise<LighthouseApiResult<ProcessBehaviorChart>>;
+  readonly getPortfolioProcessBehaviorChart: (portfolioId: number, range: MetricsDateRange | undefined, metricType: ProcessBehaviorMetricType) => Promise<LighthouseApiResult<ProcessBehaviorChart>>;
+  readonly getTeamSleRisk: (teamId: number) => Promise<LighthouseApiResult<readonly SleRiskEntry[]>>;
+  readonly getTeamCumulativeStateTime: (teamId: number, range?: MetricsDateRange, itemIds?: readonly number[]) => Promise<LighthouseApiResult<CumulativeStateTimeResult>>;
+  readonly getTeamCumulativeStateTimeItems: (teamId: number, state: string, range?: MetricsDateRange, itemIds?: readonly number[]) => Promise<LighthouseApiResult<CumulativeStateTimeItemsResult>>;
+  readonly getTeamCumulativeStateTimeCandidates: (teamId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<CumulativeStateTimeCandidatesResult>>;
+  readonly getPortfolioCumulativeStateTime: (portfolioId: number, range?: MetricsDateRange, itemIds?: readonly number[]) => Promise<LighthouseApiResult<CumulativeStateTimeResult>>;
+  readonly getPortfolioCumulativeStateTimeItems: (portfolioId: number, state: string, range?: MetricsDateRange, itemIds?: readonly number[]) => Promise<LighthouseApiResult<CumulativeStateTimeItemsResult>>;
+  readonly getPortfolioCumulativeStateTimeCandidates: (portfolioId: number, range?: MetricsDateRange) => Promise<LighthouseApiResult<CumulativeStateTimeCandidatesResult>>;
+  readonly getFeaturesByIds: (ids: readonly number[]) => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getFeaturesByReferences: (refs: readonly string[]) => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly getFeatureWorkItems: (featureId: number) => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly listDeliveries: (portfolioId: number) => Promise<LighthouseApiResult<readonly unknown[]>>;
+  readonly createDelivery: (portfolioId: number, payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
+  readonly updateDelivery: (deliveryId: number, payload: LighthouseWritePayload) => Promise<LighthouseApiResult<unknown>>;
+  readonly deleteDelivery: (deliveryId: number) => Promise<LighthouseApiResult<undefined>>;
+  readonly getDeliveryMetricsHistory: (deliveryId: number) => Promise<LighthouseApiResult<DeliveryMetricsHistory>>;
+  readonly getRecurringBlackoutRules: () => Promise<LighthouseApiResult<readonly RecurringBlackoutRule[]>>;
+  readonly createRecurringBlackoutRule: (payload: LighthouseWritePayload) => Promise<LighthouseApiResult<RecurringBlackoutRule>>;
+  readonly updateRecurringBlackoutRule: (id: number, payload: LighthouseWritePayload) => Promise<LighthouseApiResult<RecurringBlackoutRule>>;
+  readonly deleteRecurringBlackoutRule: (id: number) => Promise<LighthouseApiResult<undefined>>;
+  readonly runManualForecast: (teamId: number, payload: ManualForecastInput) => Promise<LighthouseApiResult<unknown>>;
+  readonly runBacktest: (teamId: number, payload: BacktestInput) => Promise<LighthouseApiResult<unknown>>;
+  readonly getUsageDataState: (options?: UsageDataCallOptions) => Promise<LighthouseApiResult<UsageDataState>>;
+  /** Records a yes; the value is the consent token Lighthouse minted for it. */
+  readonly grantUsageData: (options?: UsageDataCallOptions) => Promise<LighthouseApiResult<string>>;
+  readonly revokeUsageData: (options: UsageDataCallOptions & {
+    readonly token: string;
+  }) => Promise<LighthouseApiResult<undefined>>;
+  readonly handInUsageData: (batch: UsageDataBatch, options: UsageDataCallOptions & {
+    readonly token: string;
+  }) => Promise<LighthouseApiResult<undefined>>;
+};
+export type UsageDataCallOptions = {
+  readonly token?: string;
+  readonly signal?: AbortSignal;
+};
+export type LighthouseClientDependencies = {
+  readonly fetch?: (url: string, init?: RequestInit) => Promise<ConnectivityFetchResponse>;
 };
 /**
  * Server-version gating for endpoints that did not exist in older Lighthouse
@@ -493,22 +1809,26 @@ type LighthouseClientDependencies = {
  * callable. Update the baseline to the current latest release whenever a new
  * server-dependent feature is wrapped.
  */
-declare const FEATURE_REQUIRES_SERVER_NEWER_THAN: {
-    readonly cumulativeStateTime: "v26.5.24.10";
-    readonly recurringBlackoutRules: "v26.5.29.5";
-    readonly workItemAgePercentiles: "v26.6.7.1";
-    readonly mcpOAuthPassThrough: "v26.6.16.14";
-    readonly blockedCountHistory: "v26.7.3.1";
-    readonly percentilesOverTime: "v26.7.11.4";
-    readonly processBehaviorOverTime: "v26.7.11.4";
-    readonly deliveryMetricsHistory: "v26.5.29.5";
+export declare const FEATURE_REQUIRES_SERVER_NEWER_THAN: {
+  readonly cumulativeStateTime: "v26.5.24.10";
+  readonly recurringBlackoutRules: "v26.5.29.5";
+  readonly workItemAgePercentiles: "v26.6.7.1";
+  readonly mcpOAuthPassThrough: "v26.6.16.14";
+  readonly blockedCountHistory: "v26.7.3.1";
+  readonly percentilesOverTime: "v26.7.11.4";
+  readonly processBehaviorOverTime: "v26.7.11.4";
+  readonly deliveryMetricsHistory: "v26.5.29.5";
+  readonly sleRisk: "v26.9.19.10";
+  readonly teamRefinement: "v26.10.3.6";
+  readonly refinementVotes: "v26.10.3.6";
 };
 /**
  * Returns true when `candidate` is strictly newer than `baseline`, false when
  * it is equal-or-older, and null when either string is unparseable (treat as
  * "unknown — do not block").
  */
-declare const isServerVersionNewerThan: (candidate: string, baseline: string) => boolean | null;
-declare const createLighthouseClient: (configuration: LighthouseClientConfiguration, dependencies?: LighthouseClientDependencies) => LighthouseClient;
-
-export { type BacktestInput, type BlockedCountSnapshot, type CliAuthSessionPollResult, type CliAuthSessionStartError, type CliAuthSessionStartOutcome, type CliAuthSessionStartResult, type CliConnection, type CliServerAuthMode, type CliServerConnection, type CliStandaloneConnection, type ClientCapability, type ClientPackageContract, type ConnectivityCategory, type ConnectivityDependencies, type ConnectivityFetchResponse, type ConnectivityValidationResult, type CumulativeStateTimeCandidateRow, type CumulativeStateTimeCandidatesResult, type CumulativeStateTimeItemRow, type CumulativeStateTimeItemsResult, type CumulativeStateTimeResult, type CumulativeStateTimeStateRow, type DailyTotalWorkItemAge, type DailyWorkItemAge, type DayOfWeek, type DeliveryFeatureMetric, type DeliveryMetricsHistory, type DeliveryMetricsHistoryPoint, type DeliveryMetricsHistorySummaryRow, type DeliveryWhenDistributionPoint, FEATURE_REQUIRES_SERVER_NEWER_THAN, type LighthouseApiError, type LighthouseApiResult, type LighthouseAuthContext, type LighthouseAuthOverrides, type LighthouseAuthStatus, type LighthouseAuthStore, type LighthouseClient, type LighthouseClientAuth, type LighthouseClientConfiguration, type LighthouseClientDependencies, type LighthouseConnectionConfiguration, type LighthouseWritePayload, type ManualForecastInput, type MetricsDateRange, type PercentilesOverTimeMetricType, type PercentilesOverTimeSnapshot, type ProcessBehaviorMetricType, type ProcessBehaviorSnapshot, type RecurringBlackoutRule, type RecurringBlackoutRuleInput, type ResolvedLighthouseEndpoint, type ServerAuthModeResult, type StandaloneDiscoveryContract, type StandaloneDiscoveryContractParseResult, type StoredLighthouseAuth, type ThroughputFilterView, type TotalWorkItemAgeOverTimeResult, type WorkItemAgeEntry, type WorkItemAgeOverTimeResult, createLighthouseAuthContext, createLighthouseClient, getClientPackageContract, getDefaultMetricsDateRange, getStandaloneDiscoveryLockfilePath, isServerVersionNewerThan, loadStandaloneDiscoveryContract, parseStandaloneDiscoveryContract, pollCliAuthSession, queryServerAuthMode, startCliAuthSession, summariseDeliveryMetricsHistory, validateLighthouseConnectivity };
+export declare const isServerVersionNewerThan: (candidate: string, baseline: string) => boolean | null;
+/** The header a client sends its voter key in, so Lighthouse can tell its votes from anyone else's. */
+export declare const VOTER_KEY_HEADER = "X-Lighthouse-Voter-Key";
+export declare const createLighthouseClient: (configuration: LighthouseClientConfiguration, dependencies?: LighthouseClientDependencies) => LighthouseClient;
+//#endregion