@actuarial-ts/data 0.2.0 → 0.4.0

package/src/lossRun.ts

@@ -0,0 +1,176 @@
+import type { ClaimSnapshot } from "@actuarial-ts/core";
+import { ReservingError } from "@actuarial-ts/core";
+import { parseCsv } from "./csv.js";
+
+/**
+ * Loss-run CSV import. Mirrors the workbench import contract:
+ *
+ * Required columns (one row per claim per evaluation snapshot):
+ *   claim_id, accident_date, report_date, evaluation_date,
+ *   paid_to_date, case_reserve, status
+ *
+ * Headers are normalized (trimmed, lower-cased, whitespace -> underscores);
+ * extra columns are ignored. Missing required columns make the file
+ * unparseable and throw ReservingError("SHAPE", ...). Row-level failures are
+ * collected — not thrown — so the caller decides whether to abort or load
+ * the clean rows; a row with any error contributes no claim.
+ *
+ * Row numbers in errors are the 1-based PHYSICAL line in the file where the
+ * row starts (header included; blank lines and newlines inside quoted fields
+ * count), so in a file with no blank lines the first data row is row 2.
+ *
+ * Unlike the workbench importer, negative paid/case amounts are accepted
+ * here: the ASOP 23 review layer (reviewClaimData) flags them, keeping the
+ * signal visible instead of silently rejecting salvage/subrogation rows.
+ */
+
+const REQUIRED_COLUMNS = [
+  "claim_id",
+  "accident_date",
+  "report_date",
+  "evaluation_date",
+  "paid_to_date",
+  "case_reserve",
+  "status",
+] as const;
+
+export interface LossRunRowError {
+  /** 1-based physical file line where the row starts (first data row = 2 when nothing precedes it). */
+  row: number;
+  message: string;
+}
+
+export interface LossRunParseResult {
+  claims: ClaimSnapshot[];
+  errors: LossRunRowError[];
+}
+
+function normalizeHeader(h: string): string {
+  return h.trim().toLowerCase().replace(/\s+/g, "_");
+}
+
+/** True when the string is a real calendar date in yyyy-mm-dd form. */
+function isValidIsoDate(value: string): boolean {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return false;
+  const y = Number(match[1]);
+  const m = Number(match[2]);
+  const d = Number(match[3]);
+  if (m < 1 || m > 12 || d < 1) return false;
+  // Arithmetic rule, mirroring compliance/src/metadata.ts (this package cannot
+  // import compliance — the dependency points the other way). The previous
+  // Date.UTC form mapped years 0-99 into the 1900s; the mapping happens to
+  // preserve leapness for every year except 0000, so this is a correctness-of-
+  // form consolidation rather than a live-bug fix.
+  const leap = (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0;
+  const daysInMonth = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][m - 1]!;
+  return d <= daysInMonth;
+}
+
+/** Parses a loss-run CSV into ClaimSnapshots plus per-row validation errors. */
+export function parseLossRunCsv(text: string): LossRunParseResult {
+  const { rows: grid, rowLines, warnings: csvWarnings } = parseCsv(text);
+  const headers = (grid[0] ?? []).map(normalizeHeader);
+  const missing = REQUIRED_COLUMNS.filter((c) => !headers.includes(c));
+  if (missing.length > 0) {
+    throw new ReservingError(
+      "SHAPE",
+      `Missing required column(s): ${missing.join(", ")}. Found: ${
+        headers.filter(Boolean).join(", ") || "(none)"
+      }`,
+    );
+  }
+  const columnIndex = new Map<string, number>();
+  headers.forEach((h, idx) => {
+    if (!columnIndex.has(h)) columnIndex.set(h, idx);
+  });
+
+  const claims: ClaimSnapshot[] = [];
+  const errors: LossRunRowError[] = [];
+  for (const warning of csvWarnings) {
+    // Structural CSV problems surface through the same channel as row errors:
+    // partial loading is intended behavior here, silent partial loading is not.
+    const lineMatch = warning.match(/line (\d+)/);
+    errors.push({ row: lineMatch ? Number(lineMatch[1]) : 1, message: `CSV structure: ${warning}` });
+  }
+
+  for (let r = 1; r < grid.length; r++) {
+    // Physical 1-based line in the file where this row starts — NOT r + 1:
+    // blank lines and quoted embedded newlines make grid index and file line
+    // diverge, and the structural-warning path above already reports physical
+    // lines. One errors array, one numbering scheme.
+    const rowNumber = rowLines[r]!;
+    const cells = grid[r]!;
+    const cell = (name: string): string => (cells[columnIndex.get(name)!] ?? "").trim();
+    const rowErrors: string[] = [];
+
+    const claimId = cell("claim_id");
+    if (claimId === "") rowErrors.push("claim_id is required");
+
+    const date = (name: string): string | null => {
+      const value = cell(name);
+      if (!isValidIsoDate(value)) {
+        rowErrors.push(`${name} must be a real calendar date in yyyy-mm-dd form (got "${value}")`);
+        return null;
+      }
+      return value;
+    };
+    const accidentDate = date("accident_date");
+    const reportDate = date("report_date");
+    const evaluationDate = date("evaluation_date");
+
+    const amount = (name: string): number | null => {
+      const value = cell(name);
+      // Currency is decimal digits with an optional sign and fraction —
+      // Number() also accepts hex (0x2710 -> 10000), binary, octal and
+      // scientific notation, which silently changes magnitudes instead of
+      // erroring. Formatted amounts are rejected with a pointed message
+      // rather than guessed at: "1,234" could be one thousand or 1.234
+      // depending on locale, and a loss run is no place to guess.
+      if (/[,()]|\s/.test(value.trim()) && value.trim() !== "") {
+        rowErrors.push(
+          `${name} must be an unformatted decimal (got "${value}"); remove thousands separators, ` +
+            "parentheses and spaces",
+        );
+        return null;
+      }
+      const n = /^-?\d+(\.\d+)?$/.test(value.trim()) ? Number(value.trim()) : NaN;
+      if (!Number.isFinite(n)) {
+        rowErrors.push(`${name} must be a finite decimal number (got "${value}")`);
+        return null;
+      }
+      return n;
+    };
+    const paidToDate = amount("paid_to_date");
+    const caseReserve = amount("case_reserve");
+
+    const statusRaw = cell("status").toLowerCase();
+    const status: "open" | "closed" | null =
+      statusRaw === "open" || statusRaw === "closed" ? statusRaw : null;
+    if (status === null) {
+      rowErrors.push(`status must be "open" or "closed" (got "${cell("status")}")`);
+    }
+
+    // Cross-field checks need all three dates to be individually valid.
+    if (accidentDate !== null && reportDate !== null && evaluationDate !== null) {
+      if (reportDate < accidentDate) rowErrors.push("report_date precedes accident_date");
+      if (evaluationDate < reportDate) rowErrors.push("evaluation_date precedes report_date");
+    }
+
+    if (rowErrors.length > 0) {
+      for (const message of rowErrors) errors.push({ row: rowNumber, message });
+      continue;
+    }
+    claims.push({
+      claimId,
+      accidentDate: accidentDate!,
+      reportDate: reportDate!,
+      evaluationDate: evaluationDate!,
+      paidToDate: paidToDate!,
+      caseReserve: caseReserve!,
+      status: status!,
+    });
+  }
+
+  return { claims, errors };
+}

package/src/review.ts

@@ -0,0 +1,425 @@
+import type { ClaimSnapshot, Triangle } from "@actuarial-ts/core";
+
+/**
+ * ASOP No. 23 (Data Quality)-oriented data review.
+ *
+ * The report lists every check PERFORMED, not just the ones that found
+ * something — the actuary's disclosure needs "what was reviewed" as much as
+ * "what was found". A check that could not be evaluated (no as-of date; a
+ * triangle shape mismatch blocking cell comparisons) stays in the report
+ * with an explicit "not evaluated" detail so the disclosure never overstates
+ * the review.
+ *
+ * Severity philosophy:
+ * - "fail"    = the data is wrong or internally inconsistent (negative paid,
+ *               dates out of order, duplicate snapshots, paid > incurred).
+ * - "warning" = legitimate but rare/reportable (negative case reserves,
+ *               salvage-driven negative incremental paid, closed claims
+ *               still carrying case).
+ *
+ * These utilities are designed to support the actuary's compliance with
+ * ASOP No. 23; responsibility for compliance remains with the credentialed
+ * actuary.
+ */
+
+export type DataCheckStatus = "pass" | "warning" | "fail" | "not-evaluated";
+
+export interface DataFindingContext {
+  origin?: string;
+  valuation?: string;
+  ageMonths?: number;
+  group?: string;
+  sourceFile?: string;
+  sourceRow?: number;
+}
+
+export interface DataFinding {
+  /** Stable machine-readable finding code, usually the containing check id. */
+  code: string;
+  message: string;
+  context?: DataFindingContext;
+}
+
+export interface DataCheck {
+  id: string;
+  description: string;
+  status: DataCheckStatus;
+  details: string[];
+  /** Additive structured detail for consumers that should not parse prose. */
+  findings?: DataFinding[];
+}
+
+export interface DataReviewReport {
+  checks: DataCheck[];
+  summary: { pass: number; warning: number; fail: number; notEvaluated: number };
+}
+
+export interface ReviewClaimDataOptions {
+  /** ISO date; when given, any claim date after it fails "future-dated". */
+  asOfDate?: string;
+}
+
+/** At most this many offending items are listed per check, then "+N more". */
+const MAX_DETAILS = 20;
+
+function capDetails(items: string[]): string[] {
+  if (items.length <= MAX_DETAILS) return items;
+  return [...items.slice(0, MAX_DETAILS), `+${items.length - MAX_DETAILS} more`];
+}
+
+function makeCheck(
+  id: string,
+  description: string,
+  statusWhenFound: "warning" | "fail",
+  findings: string[],
+): DataCheck {
+  return {
+    id,
+    description,
+    status: findings.length > 0 ? statusWhenFound : "pass",
+    details: capDetails(findings),
+  };
+}
+
+function notEvaluated(id: string, description: string, reason: string): DataCheck {
+  // A check that could not run is REPORTED as such - counting it as "pass"
+  // would overstate the review in the very disclosure this feeds.
+  return { id, description, status: "not-evaluated", details: [`not evaluated: ${reason}`] };
+}
+
+function summarize(checks: DataCheck[]): DataReviewReport {
+  const summary = { pass: 0, warning: 0, fail: 0, notEvaluated: 0 };
+  for (const c of checks) {
+    if (c.status === "not-evaluated") summary.notEvaluated++;
+    else summary[c.status]++;
+  }
+  return { checks, summary };
+}
+
+/** Builds a structured check while retaining the established status/details contract. */
+export function createStructuredDataCheck(
+  id: string,
+  description: string,
+  statusWhenFound: "warning" | "fail",
+  findings: readonly DataFinding[],
+): DataCheck {
+  const capped = findings.length <= MAX_DETAILS ? [...findings] : [...findings.slice(0, MAX_DETAILS)];
+  const details = capped.map((finding) => finding.message);
+  if (findings.length > MAX_DETAILS) details.push(`+${findings.length - MAX_DETAILS} more`);
+  return {
+    id,
+    description,
+    status: findings.length > 0 ? statusWhenFound : "pass",
+    details,
+    findings: capped,
+  };
+}
+
+/** Public report summarizer for additive review suites. */
+export function summarizeDataChecks(checks: DataCheck[]): DataReviewReport {
+  return summarize(checks);
+}
+
+/** Public not-evaluated constructor so additive suites preserve report semantics. */
+export function createNotEvaluatedDataCheck(
+  id: string,
+  description: string,
+  reason: string,
+): DataCheck {
+  return notEvaluated(id, description, reason);
+}
+
+const CLAIM_DESCRIPTIONS = {
+  "non-finite-value": "Every money field is a finite number (no NaN or Infinity)",
+  "negative-paid": "Cumulative paid amounts are non-negative",
+  "negative-case": "Case reserves are non-negative (negative case is legitimate but rare)",
+  "paid-decreasing":
+    "Cumulative paid never decreases across a claim's snapshots ordered by evaluation date",
+  "date-order": "accident_date <= report_date <= evaluation_date on every snapshot",
+  "duplicate-snapshot": "No claim has two snapshots at the same evaluation date",
+  "future-dated": "No claim date exceeds the as-of date",
+  "closed-with-case": "Closed claims carry no outstanding case reserve",
+} as const;
+
+/** Reviews claim-level snapshots against the ASOP 23-oriented check suite. */
+export function reviewClaimData(
+  claims: ClaimSnapshot[],
+  opts: ReviewClaimDataOptions = {},
+): DataReviewReport {
+  const negativePaid: string[] = [];
+  const negativeCase: string[] = [];
+  const dateOrder: string[] = [];
+  const futureDated: string[] = [];
+  const closedWithCase: string[] = [];
+
+  claims.forEach((c) => {
+    // Identified by claimId + evaluation date, which the DATA carries. The old
+    // label fabricated "row N" from this array's index — but this function
+    // receives parsed claims, not the file, and parseLossRunCsv numbers real
+    // physical file lines in its own errors. Two different "row" meanings
+    // pointed auditors at the wrong line; an identifier we cannot compute is
+    // one we must not print.
+    const where = `claim ${c.claimId} (eval ${c.evaluationDate})`;
+    if (c.paidToDate < 0) {
+      negativePaid.push(`${where}: paid_to_date ${c.paidToDate}`);
+    }
+    if (c.caseReserve < 0) {
+      negativeCase.push(`${where}: case_reserve ${c.caseReserve}`);
+    }
+    if (c.reportDate < c.accidentDate) {
+      dateOrder.push(
+        `${where}: report_date ${c.reportDate} precedes accident_date ${c.accidentDate}`,
+      );
+    }
+    if (c.evaluationDate < c.reportDate) {
+      dateOrder.push(
+        `${where}: evaluation_date ${c.evaluationDate} precedes report_date ${c.reportDate}`,
+      );
+    }
+    if (opts.asOfDate !== undefined) {
+      const asOf = opts.asOfDate;
+      if (c.accidentDate > asOf) {
+        futureDated.push(`${where}: accident_date ${c.accidentDate} exceeds as-of ${asOf}`);
+      }
+      if (c.reportDate > asOf) {
+        futureDated.push(`${where}: report_date ${c.reportDate} exceeds as-of ${asOf}`);
+      }
+      if (c.evaluationDate > asOf) {
+        futureDated.push(`${where}: evaluation_date ${c.evaluationDate} exceeds as-of ${asOf}`);
+      }
+    }
+    if (c.status === "closed" && c.caseReserve > 0) {
+      closedWithCase.push(`${where}: case_reserve ${c.caseReserve} on a closed claim`);
+    }
+  });
+
+  // Per-claim timeline checks: duplicates and decreasing cumulative paid.
+  const byClaim = new Map<string, ClaimSnapshot[]>();
+  for (const c of claims) {
+    const list = byClaim.get(c.claimId);
+    if (list) list.push(c);
+    else byClaim.set(c.claimId, [c]);
+  }
+  const paidDecreasing: string[] = [];
+  const duplicates: string[] = [];
+  for (const [claimId, snaps] of byClaim) {
+    const sorted = [...snaps].sort((a, b) => a.evaluationDate.localeCompare(b.evaluationDate));
+    const seenEvals = new Set<string>();
+    for (const s of sorted) {
+      if (seenEvals.has(s.evaluationDate)) {
+        duplicates.push(`claim ${claimId}: duplicate snapshot at ${s.evaluationDate}`);
+      }
+      seenEvals.add(s.evaluationDate);
+    }
+    for (let k = 1; k < sorted.length; k++) {
+      const prev = sorted[k - 1]!;
+      const cur = sorted[k]!;
+      // Same-date pairs are the duplicate check's finding, not this one's.
+      if (cur.evaluationDate === prev.evaluationDate) continue;
+      if (cur.paidToDate < prev.paidToDate) {
+        paidDecreasing.push(
+          `claim ${claimId}: paid_to_date ${prev.paidToDate} -> ${cur.paidToDate} between ${prev.evaluationDate} and ${cur.evaluationDate}`,
+        );
+      }
+    }
+  }
+
+  const nonFinite: string[] = [];
+  for (const c of claims) {
+    const where = `claim ${c.claimId}`;
+    if (!Number.isFinite(c.paidToDate)) nonFinite.push(`${where}: paid_to_date ${String(c.paidToDate)}`);
+    if (!Number.isFinite(c.caseReserve)) nonFinite.push(`${where}: case_reserve ${String(c.caseReserve)}`);
+  }
+
+  const futureCheck =
+    opts.asOfDate === undefined
+      ? notEvaluated("future-dated", CLAIM_DESCRIPTIONS["future-dated"], "no asOfDate provided")
+      : makeCheck("future-dated", CLAIM_DESCRIPTIONS["future-dated"], "fail", futureDated);
+
+  return summarize([
+    // First: if the numbers are not numbers, the other verdicts are noise.
+    makeCheck("non-finite-value", CLAIM_DESCRIPTIONS["non-finite-value"], "fail", nonFinite),
+    makeCheck("negative-paid", CLAIM_DESCRIPTIONS["negative-paid"], "fail", negativePaid),
+    makeCheck("negative-case", CLAIM_DESCRIPTIONS["negative-case"], "warning", negativeCase),
+    makeCheck("paid-decreasing", CLAIM_DESCRIPTIONS["paid-decreasing"], "fail", paidDecreasing),
+    makeCheck("date-order", CLAIM_DESCRIPTIONS["date-order"], "fail", dateOrder),
+    makeCheck("duplicate-snapshot", CLAIM_DESCRIPTIONS["duplicate-snapshot"], "fail", duplicates),
+    futureCheck,
+    makeCheck("closed-with-case", CLAIM_DESCRIPTIONS["closed-with-case"], "warning", closedWithCase),
+  ]);
+}
+
+const TRIANGLE_DESCRIPTIONS = {
+  "non-finite-value": "Every observed cell is a finite number (no NaN or Infinity)",
+  "shape-mismatch": "Paid and incurred triangles share the same origins and ages",
+  "paid-exceeds-incurred": "Paid never exceeds incurred in any cell (1e-9 relative tolerance)",
+  "negative-incremental-paid":
+    "Cumulative paid is non-decreasing along each origin row (salvage/subrogation can legitimately violate this)",
+  "negative-incremental-incurred":
+    "Cumulative incurred is non-decreasing along each origin row (case takedowns can legitimately violate this)",
+  "interior-missing": "No row has a missing cell between observed cells",
+} as const;
+
+/**
+ * Findings for NaN/Infinity in observed cells. This check exists because every
+ * OTHER check is a relational comparison, and every relational comparison is
+ * false for NaN — so without it, a triangle of NaN cells passes the entire
+ * review and renders into disclosure Section 3 as clean data. It runs FIRST:
+ * if the numbers are not numbers, the other verdicts are noise.
+ */
+function nonFiniteTriangleFindings(tri: Triangle): string[] {
+  const out: string[] = [];
+  for (let i = 0; i < tri.values.length; i++) {
+    const row = tri.values[i]!;
+    for (let j = 0; j < row.length; j++) {
+      const v = row[j];
+      if (v === null || v === undefined) continue;
+      if (!Number.isFinite(v)) {
+        out.push(`${tri.kind} ${tri.origins[i]} age ${tri.ages[j]}: ${String(v)}`);
+      }
+    }
+  }
+  return out;
+}
+
+/** Findings where a row's cumulative values decrease between observed cells. */
+function negativeIncrementalFindings(tri: Triangle): string[] {
+  const out: string[] = [];
+  for (let i = 0; i < tri.values.length; i++) {
+    const row = tri.values[i]!;
+    let prev: number | null = null;
+    let prevAge: number | null = null;
+    for (let j = 0; j < row.length; j++) {
+      const v = row[j];
+      if (v === null || v === undefined) continue;
+      const age = tri.ages[j]!;
+      if (prev !== null && v < prev) {
+        out.push(
+          `${tri.kind} ${tri.origins[i]} age ${prevAge} -> ${age}: ${prev} -> ${v}`,
+        );
+      }
+      prev = v;
+      prevAge = age;
+    }
+  }
+  return out;
+}
+
+/** Findings for null cells with observed cells both before and after in the row. */
+function interiorMissingFindings(tri: Triangle): string[] {
+  const out: string[] = [];
+  for (let i = 0; i < tri.values.length; i++) {
+    const row = tri.values[i]!;
+    // undefined and null are both absences (a JSON round-trip can produce
+    // either); the negative-incremental walk above already treats them
+    // identically, and a gap must not change meaning between checks.
+    const observed = row.map((v) => v !== null && v !== undefined);
+    const first = observed.indexOf(true);
+    const last = observed.lastIndexOf(true);
+    if (first === -1) continue;
+    for (let j = first + 1; j < last; j++) {
+      if (!observed[j]) {
+        out.push(`${tri.kind} ${tri.origins[i]} age ${tri.ages[j]}: interior cell missing`);
+      }
+    }
+  }
+  return out;
+}
+
+/** Reviews a paid/incurred triangle pair for cross-triangle consistency. */
+export function reviewTriangles(paid: Triangle, incurred: Triangle): DataReviewReport {
+  const shapeFindings: string[] = [];
+  const sameOrigins =
+    paid.origins.length === incurred.origins.length &&
+    paid.origins.every((o, i) => o === incurred.origins[i]);
+  const sameAges =
+    paid.ages.length === incurred.ages.length &&
+    paid.ages.every((a, j) => a === incurred.ages[j]);
+  if (!sameOrigins) {
+    shapeFindings.push(
+      `origins differ: paid [${paid.origins.join(", ")}] vs incurred [${incurred.origins.join(", ")}]`,
+    );
+  }
+  if (!sameAges) {
+    shapeFindings.push(
+      `ages differ: paid [${paid.ages.join(", ")}] vs incurred [${incurred.ages.join(", ")}]`,
+    );
+  }
+  const nonFiniteCheck = makeCheck(
+    "non-finite-value",
+    TRIANGLE_DESCRIPTIONS["non-finite-value"],
+    "fail",
+    [...nonFiniteTriangleFindings(paid), ...nonFiniteTriangleFindings(incurred)],
+  );
+  const shapeCheck = makeCheck(
+    "shape-mismatch",
+    TRIANGLE_DESCRIPTIONS["shape-mismatch"],
+    "fail",
+    shapeFindings,
+  );
+  if (shapeFindings.length > 0) {
+    // Cell-level comparisons are meaningless across mismatched grids; the
+    // remaining checks stay listed (disclosure) but are not evaluated.
+    const reason = "triangle shapes differ";
+    return summarize([
+      nonFiniteCheck,
+      shapeCheck,
+      notEvaluated("paid-exceeds-incurred", TRIANGLE_DESCRIPTIONS["paid-exceeds-incurred"], reason),
+      notEvaluated(
+        "negative-incremental-paid",
+        TRIANGLE_DESCRIPTIONS["negative-incremental-paid"],
+        reason,
+      ),
+      notEvaluated(
+        "negative-incremental-incurred",
+        TRIANGLE_DESCRIPTIONS["negative-incremental-incurred"],
+        reason,
+      ),
+      notEvaluated("interior-missing", TRIANGLE_DESCRIPTIONS["interior-missing"], reason),
+    ]);
+  }
+
+  const paidExceeds: string[] = [];
+  for (let i = 0; i < paid.values.length; i++) {
+    const paidRow = paid.values[i]!;
+    const incRow = incurred.values[i]!;
+    for (let j = 0; j < paidRow.length; j++) {
+      const p = paidRow[j];
+      const inc = incRow[j];
+      if (p === null || p === undefined || inc === null || inc === undefined) continue;
+      const tolerance = 1e-9 * Math.max(1, Math.abs(p), Math.abs(inc));
+      if (p - inc > tolerance) {
+        paidExceeds.push(`${paid.origins[i]} age ${paid.ages[j]}: paid ${p} > incurred ${inc}`);
+      }
+    }
+  }
+
+  return summarize([
+    nonFiniteCheck,
+    shapeCheck,
+    makeCheck(
+      "paid-exceeds-incurred",
+      TRIANGLE_DESCRIPTIONS["paid-exceeds-incurred"],
+      "fail",
+      paidExceeds,
+    ),
+    makeCheck(
+      "negative-incremental-paid",
+      TRIANGLE_DESCRIPTIONS["negative-incremental-paid"],
+      "warning",
+      negativeIncrementalFindings(paid),
+    ),
+    makeCheck(
+      "negative-incremental-incurred",
+      TRIANGLE_DESCRIPTIONS["negative-incremental-incurred"],
+      "warning",
+      negativeIncrementalFindings(incurred),
+    ),
+    makeCheck(
+      "interior-missing",
+      TRIANGLE_DESCRIPTIONS["interior-missing"],
+      "warning",
+      [...interiorMissingFindings(paid), ...interiorMissingFindings(incurred)],
+    ),
+  ]);
+}