@ampath/esm-dha-workflow-app 4.0.0-next.44 → 4.0.0-next.445

package/src/shr/shr.types.ts

@@ -0,0 +1,682 @@
+/**
+ * Types for the national Shared Health Record (SHR) consent workflow and record viewer.
+ *
+ * Two groups live here:
+ *
+ *  1. The four `/shr/*` endpoint contracts (§ create consent, verify OTP, fetch
+ *     records, close visit). Field names and casing mirror the real backend
+ *     exactly — camelCase on the way in, DHA's snake_case on the way back.
+ *  2. The FHIR shapes the SHR actually returns. These are ported from
+ *     `ampath-esm-hie-registry-manager-app`'s `src/hie/shr/shr-details/types`,
+ *     where they were confirmed against this same HIE/SHR backend, and widened
+ *     with a few optional fields the viewer renders when present.
+ */
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Endpoint contracts
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Visit type accepted by the consent endpoint. Distinct from the claims domain's `VisitType`. */
+export type ShrVisitType = 'IP' | 'OP';
+
+/**
+ * How a representative relates to the patient they consent for. Exactly the
+ * four values DHA accepts — anything else is rejected upstream.
+ */
+export type ShrRepresentativeRelationship = 'Healthcare Proxy' | 'Sibling' | 'Principal' | 'Other';
+
+export const SHR_REPRESENTATIVE_RELATIONSHIPS: ShrRepresentativeRelationship[] = [
+  'Healthcare Proxy',
+  'Sibling',
+  'Principal',
+  'Other',
+];
+
+/** The patient's decision, as recorded on the verify call. */
+export type ShrConsentDecision = 'Approve' | 'Reject';
+export interface CreateConsentRequest {
+  crId: string;
+  locationUuid: string;
+  requestedBy: string;
+  visitType: ShrVisitType;
+  emergency: 0 | 1;
+  /** 1 = the patient can consent for themselves (the default). 0 requires a representative. */
+  patientCapable?: 0 | 1;
+  incapacityReason?: string;
+  representativeCrId?: string;
+  representativeRelationship?: ShrRepresentativeRelationship;
+}
+
+/**
+ * Response from `POST /shr/consents`. Two shapes, and which arrived decides
+ * what happens next:
+ *
+ *  - **standard** — `otp_record` and no token, so the OTP step follows
+ *  - **emergency** — approved on the spot, so `consent_token` + `visit_id`
+ *    arrive with no `otp_record` and there is no OTP step to run
+ */
+export interface CreateConsentResponse {
+  consent_id: string;
+  consent_status: string;
+  /**
+   * Opaque handle that must be echoed back to the verify endpoint. Absent on an
+   * emergency consent, which needs no password.
+   */
+  otp_record?: string;
+  visit_type: string;
+  /** Only on an emergency consent, which is approved without an OTP. */
+  consent_token?: string;
+  /** Only on an emergency consent; a standard consent gets it at verification. */
+  visit_id?: string;
+  /** Whether consent was granted through the emergency route. */
+  emergency?: boolean;
+  message?: string;
+  status?: string;
+}
+
+/**
+ * Body for `POST {hieBaseUrl}/shr/consents/{consent_id}/verify`.
+ *
+ * One endpoint, three jobs: approving a consent with the OTP, recording a
+ * *refusal*, and completing an OTP-gated visit closure. `otpRecord` identifies
+ * which — it comes from the consent request for the first two and from the
+ * close call for the third.
+ *
+ * `otp` is optional because a refusal has none: a patient who declines never
+ * hands over a password.
+ *
+ * `crId` is not forwarded to DHA — the backend uses it to record the consent
+ * session that `GET /shr/consents/active` later answers from, so send it.
+ */
+export interface VerifyConsentRequest {
+  locationUuid: string;
+  otpRecord: string;
+  otp?: string;
+  consentDecision?: ShrConsentDecision;
+  rejectionReason?: string;
+  crId?: string;
+}
+
+/**
+ * Response from the verify endpoint. Three real outcomes, so everything but the
+ * envelope is optional and callers must branch on what actually arrived rather
+ * than assuming a 200 means "here's a token":
+ *
+ *  - **approval** — `consent_token` + `visit_id`. `visit_id` is the only source
+ *    of the visit UUID needed to close the visit later.
+ *  - **refusal** — `consent_id` + `consent_status: 'Rejected'`, no token, no
+ *    visit opened.
+ *  - **closure completion** — `end_date`, no token; the visit this verified is
+ *    now closed.
+ */
+export interface VerifyConsentResponse {
+  consent_token?: string;
+  visit_id?: string;
+  consent_id?: string;
+  consent_status?: string;
+  /** Present only when this verification completed an OTP-gated closure. */
+  end_date?: string;
+  message?: string;
+  status?: string;
+}
+
+/** What a granted consent hands to whoever fetches and renders the records. */
+export interface ShrConsentGrant {
+  consentToken: string;
+  visitId: string;
+}
+
+/**
+ * What a *refused* consent hands back. Neither an error nor a session: the
+ * request settled, no visit was opened, and nothing will be fetched.
+ */
+export interface ShrConsentDeclined {
+  consentId: string;
+  consentStatus: string;
+  rejectionReason?: string;
+}
+
+/**
+ * Body for `POST {hieBaseUrl}/shr/visits/{visit_id}/close`. Everything past
+ * `locationUuid` is optional: omitted, closure is OTP-gated as before.
+ *
+ * **Polarity gotcha.** This is `patientIncapable` — `1` means the patient
+ * *cannot* consent. The consent request uses `patientCapable`, where `1` means
+ * they *can*. Two similarly named flags on different endpoints with opposite
+ * polarity; `patientIncapable: 1` here and `patientCapable: 0` there say the
+ * same thing.
+ */
+export interface CloseVisitRequest {
+  locationUuid: string;
+  /** 1 = the patient cannot consent to the closure (unconscious, deceased). Closes immediately, no OTP. */
+  patientIncapable?: 0 | 1;
+  /** Required alongside `patientIncapable: 1`. */
+  incapacityReason?: string;
+}
+
+/**
+ * Response from `POST {hieBaseUrl}/shr/visits/{visit_id}/close`. Two outcomes,
+ * and which field arrived decides what happens next:
+ *
+ *  - `end_date` — the visit is **already closed**.
+ *  - `otp_record` — a closure OTP went out and the visit **stays open** until
+ *    that password is verified through the verify endpoint.
+ */
+export interface CloseVisitResponse {
+  consent_id?: string;
+  /** Server-supplied closure date — the visit is closed. */
+  end_date?: string;
+  /** A closure awaiting verification. The visit is NOT closed yet. */
+  otp_record?: string;
+  visit_id?: string;
+  message?: string;
+  status?: string;
+}
+
+/** Response from `GET {hieBaseUrl}/shr/open-visits`. Empty array means none. */
+export interface OpenVisitsResponse {
+  visits?: Array<{ visit_id?: string }>;
+  message?: string;
+  status?: string;
+}
+
+/**
+ * Response from the backend's own `GET {hieBaseUrl}/shr/consents/active` — its
+ * shape, not DHA's. `hasActiveConsent: false` is a normal answer meaning a
+ * fresh consent request is needed, not an error.
+ */
+export interface ActiveConsentResponse {
+  hasActiveConsent: boolean;
+  message?: string;
+  source?: 'local' | 'refreshed' | 'open-visits';
+  visitId?: string;
+  consentId?: string | null;
+  consentToken?: string;
+  tokenExpiresAt?: string | null;
+}
+
+/** Response from `POST {hieBaseUrl}/shr/visits/{visit_id}/refresh`. */
+export interface RefreshConsentResponse {
+  consent_token?: string;
+  message?: string;
+  status?: string;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Closed-visit FHIR submission (hie-saf: src/shr/visit-submission)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * The bundle family the backend builds for a closed visit:
+ *
+ *  - `emergency` — the Kenya Emergency Care IG shape the SHA enforces
+ *    (em-* profiles, incident scaffolding, triage acuity);
+ *  - `clinical` — routine non-emergency care as a base-R4 Encounter whose
+ *    class comes from the AMRS visit type.
+ */
+export type ShrVisitSubmissionFamily = 'emergency' | 'clinical';
+
+/** What a submission request may ask for: a concrete family, or `auto`. */
+export type ShrVisitSubmissionFamilySelection = 'auto' | ShrVisitSubmissionFamily;
+
+/**
+ * Body for `POST {hieBaseUrl}/shr/visit-submission` — the hie-saf backend that
+ * maps a closed AMRS visit onto a SHA-IG-compliant FHIR collection bundle and
+ * submits it to the national SHR through DHA's middleware. With no `visitUuid`
+ * the backend picks the latest closed visit for the patient at `locationUuid`.
+ */
+export interface ShrVisitSubmissionRequest {
+  patientUuid: string;
+  /**
+   * The facility submitting — scopes the visit search, resolves the facility
+   * identity for the bundle, and scopes consent-token resolution.
+   */
+  locationUuid: string;
+  /** Submit this specific closed visit instead of the latest one. */
+  visitUuid?: string;
+  /**
+   * Which bundle family to build. Omitted (or `auto`) the backend decides from
+   * the AMRS visit type — its visit-type family map, then its configured
+   * default (emergency). Pass `clinical` for routine non-emergency visits or
+   * `emergency` to force the emergency IG shape.
+   */
+  submissionFamily?: ShrVisitSubmissionFamilySelection;
+  /**
+   * Consent token when the caller still holds one (the X-Consent-Token header
+   * takes precedence on the backend); otherwise the backend resolves one from
+   * the recorded consent session.
+   */
+  consentToken?: string;
+  /** Build (+ pre-validate) the bundle but do not submit it. */
+  dryRun?: boolean;
+}
+
+/** One `OperationOutcome.issue` the SHA server reported during pre-validation. */
+export interface ShrValidationIssue {
+  severity: string;
+  diagnostics?: string;
+  location?: string[];
+  /**
+   * True when the issue matches the documented UAT ValueSet-expansion defect —
+   * the bundle is conformant; the server's ValueSets are broken (see
+   * hie-saf docs/shr-visit-submission.md, "Known UAT terminology defect").
+   */
+  knownTerminologyDefect?: boolean;
+}
+
+/**
+ * The four outcomes of a submission request. `skipped` (no closed visit) and
+ * `validated` (dry run) are both successes; only `failed` means something
+ * needs attention, and `errors` then says why.
+ */
+export type ShrVisitSubmissionStatus = 'submitted' | 'validated' | 'skipped' | 'failed';
+
+/** Response from `POST {hieBaseUrl}/shr/visit-submission`. */
+export interface ShrVisitSubmissionResponse {
+  status: ShrVisitSubmissionStatus;
+  patientUuid: string;
+  /** The closed visit that was mapped (absent on `skipped`). */
+  visitUuid?: string;
+  /** ISO datetime the visit was closed. */
+  visitClosedAt?: string;
+  /** The bundle family the backend built (and submitted). */
+  submissionFamily?: ShrVisitSubmissionFamily;
+  /** Resource count in the submitted bundle. */
+  entries?: number;
+  /** Where the consent token came from, when one was needed. */
+  consentTokenSource?: 'request' | 'active-consent';
+  /** DHA mediator's acknowledgement of the submitted bundle. */
+  mediatorId?: string;
+  mediatorMessage?: string;
+  mediatorStatus?: string;
+  /** Present when the backend pre-validated the bundle. */
+  validationIssues?: ShrValidationIssue[];
+  /** Non-fatal mapping notes, e.g. "acuity defaulted to unknown". */
+  warnings?: string[];
+  message?: string;
+  /** Present with status "failed". */
+  errors?: string[];
+}
+
+/** Discriminated error thrown by every SHR call, carrying the real HTTP status. */
+export class ShrApiError extends Error {
+  status: number;
+  constructor(status: number, message: string) {
+    super(message);
+    this.name = 'ShrApiError';
+    this.status = status;
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// FHIR shapes returned by the SHR
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface ShrMeta {
+  versionId?: string;
+  lastUpdated?: string;
+  source?: string;
+  profile?: string[];
+}
+
+export interface ShrCoding {
+  system?: string;
+  code?: string;
+  display?: string;
+}
+
+export interface ShrCodeableConcept {
+  coding?: ShrCoding[];
+  text?: string;
+}
+
+export interface ShrIdentifier {
+  use?: string;
+  system?: string;
+  value?: string;
+  type?: ShrCodeableConcept;
+}
+
+export interface ShrReference {
+  reference?: string;
+  type?: string;
+  identifier?: ShrIdentifier;
+  display?: string;
+}
+
+export interface ShrPeriod {
+  start?: string;
+  end?: string;
+}
+
+export interface ShrAnnotation {
+  authorString?: string;
+  time?: string;
+  text?: string;
+}
+
+export interface ShrQuantity {
+  value?: number;
+  unit?: string;
+  code?: string;
+}
+
+export interface ShrDosageInstruction {
+  text?: string;
+  timing?: {
+    repeat?: {
+      duration?: number;
+      durationUnit?: string;
+      frequency?: number;
+      period?: number;
+      periodUnit?: string;
+    };
+    code?: ShrCodeableConcept;
+  };
+  asNeededBoolean?: boolean;
+  route?: ShrCodeableConcept;
+  doseAndRate?: Array<{ doseQuantity?: ShrQuantity }>;
+}
+
+export interface ShrDispenseRequest {
+  validityPeriod?: ShrPeriod;
+  numberOfRepeatsAllowed?: number;
+  quantity?: ShrQuantity;
+}
+
+/** Base every SHR resource shares. */
+interface ShrResourceBase {
+  resourceType: string;
+  id?: string;
+  meta?: ShrMeta;
+  identifier?: ShrIdentifier[];
+}
+
+export interface ShrPatient extends ShrResourceBase {
+  resourceType: 'Patient';
+  name?: Array<{ text?: string; family?: string; given?: string[] }>;
+  gender?: string;
+  birthDate?: string;
+}
+
+export interface ShrEncounter extends ShrResourceBase {
+  resourceType: 'Encounter';
+  status?: string;
+  class?: ShrCoding;
+  type?: ShrCodeableConcept[];
+  priority?: ShrCodeableConcept;
+  subject?: ShrReference;
+  participant?: Array<{ individual?: { identifier?: ShrIdentifier; display?: string } }>;
+  period?: ShrPeriod;
+  serviceProvider?: ShrReference;
+}
+
+export interface ShrCondition extends ShrResourceBase {
+  resourceType: 'Condition';
+  clinicalStatus?: ShrCodeableConcept;
+  verificationStatus?: ShrCodeableConcept;
+  category?: ShrCodeableConcept[];
+  severity?: ShrCodeableConcept;
+  code?: ShrCodeableConcept;
+  subject?: ShrReference;
+  encounter?: ShrReference;
+  onsetDateTime?: string;
+  recordedDate?: string;
+  note?: ShrAnnotation[];
+}
+
+export interface ShrServiceRequest extends ShrResourceBase {
+  resourceType: 'ServiceRequest';
+  contained?: ShrAnyResource[];
+  basedOn?: Array<{ type?: string; identifier?: ShrIdentifier }>;
+  status?: string;
+  intent?: string;
+  /** Not present in every payload seen so far; rendered only when the SHR sends it. */
+  code?: ShrCodeableConcept;
+  category?: ShrCodeableConcept[];
+  priority?: string;
+  subject?: ShrReference;
+  encounter?: ShrReference;
+  occurrencePeriod?: ShrPeriod;
+  occurrenceDateTime?: string;
+  authoredOn?: string;
+  requester?: ShrReference;
+  performer?: ShrReference[];
+  reasonCode?: ShrCodeableConcept[];
+  supportingInfo?: ShrReference[];
+  note?: ShrAnnotation[];
+}
+
+export interface ShrObservation extends ShrResourceBase {
+  resourceType: 'Observation';
+  status?: string;
+  /** e.g. a "vital-signs" or "exam" coding — what splits Observations across tabs. See `ShrResourceTypeConfig.categoryCode`. */
+  category?: ShrCodeableConcept[];
+  code?: ShrCodeableConcept;
+  subject?: ShrReference;
+  encounter?: ShrReference;
+  /** The body region a physical-exam finding was recorded against. */
+  bodySite?: ShrCodeableConcept;
+  extension?: Array<{ url?: string; valueBoolean?: boolean }>;
+  valueCodeableConcept?: ShrCodeableConcept;
+  /**
+   * Only `valueCodeableConcept` is confirmed on the payloads seen so far. The
+   * remaining value/date variants are standard FHIR and are rendered when the
+   * SHR happens to send them, rather than assumed to be there.
+   */
+  valueQuantity?: ShrQuantity;
+  valueString?: string;
+  valueBoolean?: boolean;
+  valueInteger?: number;
+  effectiveDateTime?: string;
+  effectivePeriod?: ShrPeriod;
+  issued?: string;
+  interpretation?: ShrCodeableConcept[];
+  note?: ShrAnnotation[];
+}
+
+export interface ShrSpecimen extends ShrResourceBase {
+  resourceType: 'Specimen';
+  status?: string;
+  type?: ShrCodeableConcept;
+  subject?: ShrReference;
+  receivedTime?: string;
+  collection?: {
+    collectedDateTime?: string;
+    collector?: ShrReference;
+    bodySite?: ShrCodeableConcept;
+  };
+  note?: ShrAnnotation[];
+}
+
+export interface ShrMedicationRequest extends ShrResourceBase {
+  resourceType: 'MedicationRequest';
+  status?: string;
+  intent?: string;
+  priority?: string;
+  medicationCodeableConcept?: ShrCodeableConcept;
+  subject?: ShrReference;
+  encounter?: ShrReference;
+  authoredOn?: string;
+  requester?: ShrReference;
+  note?: ShrAnnotation[];
+  dosageInstruction?: ShrDosageInstruction[];
+  dispenseRequest?: ShrDispenseRequest;
+}
+
+/** One `AllergyIntolerance.reaction` entry — what happened when exposed. */
+export interface ShrReaction {
+  substance?: ShrCodeableConcept;
+  manifestation?: ShrCodeableConcept[];
+  /** mild | moderate | severe. */
+  severity?: string;
+  note?: ShrAnnotation[];
+}
+
+/**
+ * Confirmed against live SHR payloads (the `erx-ke-allergy-intolerance`
+ * profile). Unlike the seven types the viewer shipped with, AllergyIntolerance
+ * carries no `status` — its workflow state lives on `clinicalStatus`, and its
+ * `category` is an array of plain FHIR codes, not CodeableConcepts.
+ */
+export interface ShrAllergyIntolerance extends ShrResourceBase {
+  resourceType: 'AllergyIntolerance';
+  clinicalStatus?: ShrCodeableConcept;
+  verificationStatus?: ShrCodeableConcept;
+  /** allergy | intolerance. */
+  type?: string;
+  /** Plain codes — medication | environment | food | biologic — NOT CodeableConcepts. */
+  category?: string[];
+  /** low | high | unable-to-assess. */
+  criticality?: string;
+  /** What the patient reacts to. */
+  code?: ShrCodeableConcept;
+  patient?: ShrReference;
+  encounter?: ShrReference;
+  onsetDateTime?: string;
+  recordedDate?: string;
+  recorder?: ShrReference;
+  lastOccurrence?: string;
+  reaction?: ShrReaction[];
+}
+
+/** The `ke-episode-of-care` shape the SHR serves (visit-level grouping). */
+export interface ShrEpisodeOfCare extends ShrResourceBase {
+  resourceType: 'EpisodeOfCare';
+  status?: string;
+  statusHistory?: Array<{ status?: string; period?: ShrPeriod }>;
+  type?: ShrCodeableConcept[];
+  patient?: ShrReference;
+  managingOrganization?: ShrReference;
+  period?: ShrPeriod;
+  careManager?: ShrReference;
+}
+
+/**
+ * Vaccination record. `occurrence[x]` is dateTime OR string — the string form
+ * exists for "sometime in childhood" style dates, so date rendering must
+ * tolerate a non-date.
+ */
+export interface ShrImmunization extends ShrResourceBase {
+  resourceType: 'Immunization';
+  status?: string;
+  statusReason?: ShrCodeableConcept;
+  vaccineCode?: ShrCodeableConcept;
+  occurrenceDateTime?: string;
+  occurrenceString?: string;
+  recorded?: string;
+  lotNumber?: string;
+  manufacturer?: ShrReference;
+  site?: ShrCodeableConcept;
+  doseQuantity?: ShrQuantity;
+  performer?: Array<{ actor?: ShrReference }>;
+  encounter?: ShrReference;
+  note?: ShrAnnotation[];
+}
+
+/** A clinical action carried out on the patient. `performed[x]` is dateTime | Period | string. */
+export interface ShrProcedure extends ShrResourceBase {
+  resourceType: 'Procedure';
+  status?: string;
+  statusReason?: ShrCodeableConcept;
+  category?: ShrCodeableConcept[];
+  code?: ShrCodeableConcept;
+  subject?: ShrReference;
+  encounter?: ShrReference;
+  performedDateTime?: string;
+  performedPeriod?: ShrPeriod;
+  performedString?: string;
+  performer?: Array<{ actor?: ShrReference; function?: ShrCodeableConcept }>;
+  reasonCode?: ShrCodeableConcept[];
+  asserter?: ShrReference;
+  recordedDate?: string;
+  recorder?: ShrReference;
+  note?: ShrAnnotation[];
+}
+
+/** What pharmacy handed to the patient, against a MedicationRequest. */
+export interface ShrMedicationDispense extends ShrResourceBase {
+  resourceType: 'MedicationDispense';
+  status?: string;
+  statusReason?: ShrCodeableConcept;
+  medicationCodeableConcept?: ShrCodeableConcept;
+  subject?: ShrReference;
+  encounter?: ShrReference;
+  performer?: Array<{ actor?: ShrReference }>;
+  authorizingPrescription?: ShrReference;
+  quantity?: ShrQuantity;
+  daysSupply?: ShrQuantity;
+  whenPrepared?: string;
+  whenHandedOver?: string;
+  dosageInstruction?: ShrDosageInstruction[];
+  note?: ShrAnnotation[];
+}
+
+/** A dose actually given (or deliberately not given — `status: not-done` + statusReason). */
+export interface ShrMedicationAdministration extends ShrResourceBase {
+  resourceType: 'MedicationAdministration';
+  status?: string;
+  /** Array on Administration (singular CodeableConcept on Dispense). */
+  statusReason?: ShrCodeableConcept[];
+  medicationCodeableConcept?: ShrCodeableConcept;
+  subject?: ShrReference;
+  encounter?: ShrReference;
+  effectiveDateTime?: string;
+  effectivePeriod?: ShrPeriod;
+  performer?: Array<{ actor?: ShrReference }>;
+  dosage?: { text?: string; dose?: ShrQuantity; rateQuantity?: ShrQuantity };
+  note?: ShrAnnotation[];
+}
+
+/**
+ * Any resource the SHR may hand back. The union covers the resource types the
+ * SHR's documented record set holds (plus Patient, which rides along); the
+ * index signature keeps a site-configured extra category from being a type
+ * error rather than a config change.
+ */
+export type ShrKnownResource =
+  | ShrPatient
+  | ShrEncounter
+  | ShrCondition
+  | ShrServiceRequest
+  | ShrObservation
+  | ShrSpecimen
+  | ShrMedicationRequest
+  | ShrAllergyIntolerance
+  | ShrEpisodeOfCare
+  | ShrImmunization
+  | ShrProcedure
+  | ShrMedicationDispense
+  | ShrMedicationAdministration;
+
+export type ShrAnyResource = ShrKnownResource | (ShrResourceBase & Record<string, any>);
+
+export interface ShrBundleEntry {
+  fullUrl?: string;
+  resource?: ShrAnyResource;
+  search?: { mode?: string };
+  request?: { method?: string; url?: string };
+}
+
+export interface ShrBundle {
+  resourceType: 'Bundle';
+  id?: string;
+  meta?: ShrMeta;
+  type?: string;
+  total?: number;
+  timestamp?: string;
+  link?: Array<{ relation?: string; url?: string }>;
+  entry?: ShrBundleEntry[];
+}
+
+/** Normalised result of a patient-records fetch, ready for the viewer. */
+export interface ShrRecordSet {
+  /** Every resource found in the response, flattened out of whatever envelope carried it. */
+  resources: ShrAnyResource[];
+  /** Newest `meta.lastUpdated` across the set, if any resource carried one. */
+  lastUpdated?: string;
+  /** Distinct non-empty `meta.source` values across the set. */
+  sources: string[];
+  /** The response exactly as received — kept for diagnostics, never rendered. */
+  raw: unknown;
+}