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

package/src/billing/dashboard/v3/patient-bill-details/patient-visit-details.tsx

@@ -0,0 +1,256 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import {
+  type PatientFacilityBillDetails,
+  type PatientBillVisit,
+  type ClaimsVisit,
+  type PatientPayment,
+  type PatientPaymentsDto,
+} from '../types';
+import {
+  fetchMaternityDiagnosis,
+  fetchPatientBillDetails,
+  fetchPatientBillPayments,
+  fetchPatientDiagnosis,
+  fetchPatientEncounterDiagnosis,
+  fetchPatientVisits,
+  useInvalidatePatientBillDetails,
+  usePatientBillDetails,
+} from '../../../billing-claims.resource';
+import { InlineLoading, RadioButton, RadioButtonGroup, Tab, TabList, TabPanel, TabPanels, Tabs } from '@carbon/react';
+import { formatDate, parseDate, showSnackbar } from '@openmrs/esm-framework';
+
+import styles from './patient-visit.scss';
+import BillDetails from './bill-details/bill-details';
+import PatientClaimDetails from './claim-details/patient-claim-details.component';
+import { type AmrsMaternityDiagnosisDto, type AmrsVisitDiagnosisDto, type AmrsVisitDiagnosis } from '../../../types';
+
+interface PatientVisitDetailsComponentProps {
+  patientUuid: string;
+  billingDate: string;
+  locationUuid: string;
+}
+
+const PatientVisitDetailsComponent: React.FC<PatientVisitDetailsComponentProps> = ({
+  patientUuid,
+  locationUuid,
+  billingDate,
+}) => {
+  const [patientVisits, setPatientVisits] = useState<PatientBillVisit[]>([]);
+  const [selectedVisitUuid, setSelectedVisitUuid] = useState<string>('');
+  const [claimDetails, setClaimDetails] = useState([]);
+  const [claimsVisit, setClaimsVisit] = useState<ClaimsVisit>();
+  const [patientBillPayments, setPatientBillPayments] = useState<PatientPayment[]>([]);
+  const [visitDiagnosis, setVisitDiagnosis] = useState<AmrsVisitDiagnosis[]>([]);
+  const [maternityDiagnosis, setMaternityDiagnosis] = useState<AmrsVisitDiagnosis[]>([]);
+  const [encounterDiagnosis, setEncounterDiagnosis] = useState<AmrsVisitDiagnosis[]>([]);
+  const patientAmrsVisitDiagnosis = useMemo(
+    () => [...visitDiagnosis, ...maternityDiagnosis, ...encounterDiagnosis],
+    [visitDiagnosis, maternityDiagnosis, encounterDiagnosis],
+  );
+  const [visitDiagnosisLoading, setVisitDiagnosisLoading] = useState<boolean>(true);
+  const [maternityDiagnosisLoading, setMaternityDiagnosisLoading] = useState<boolean>(true);
+  const [encounterDiagnosisLoading, setEncounterDiagnosisLoading] = useState<boolean>(true);
+  const diagnosisLoading = visitDiagnosisLoading || maternityDiagnosisLoading || encounterDiagnosisLoading;
+  const [consentToken, setConsentToken] = useState<string>('');
+
+  const { results: patientBillDetails, isLoading, isValidating } = usePatientBillDetails(selectedVisitUuid);
+  const invalidatePatientBillDetails = useInvalidatePatientBillDetails();
+
+  const getPatientVisits = async () => {
+    const res = await fetchPatientVisits(patientUuid, billingDate, locationUuid);
+    setPatientVisits(res);
+    if (res && res.length > 0) {
+      const visit = res[0];
+      setSelectedVisitUuid(visit?.visit_uuid ?? '');
+      setConsentToken(visit.consent_token ?? '');
+    }
+  };
+
+  const handVisitTypeChange = (value: any) => {
+    const selectedVisit = patientVisits.find((v) => {
+      return v.visit_uuid === value;
+    });
+    setSelectedVisitUuid(selectedVisit?.visit_uuid ?? '');
+    setConsentToken(selectedVisit?.consent_token ?? '');
+  };
+
+  useEffect(() => {
+    if (locationUuid && patientUuid && billingDate) {
+      getPatientPayments();
+      getPatientAmrsVisitDiagnosis();
+      getPatientAmrsMaternityDiagnosis();
+      getPatientAmrsEncounterDiagnosis();
+    }
+  }, [locationUuid, patientUuid, billingDate]);
+
+  useEffect(() => {
+    if (patientUuid && locationUuid && billingDate) {
+      getPatientVisits();
+    }
+  }, [locationUuid, patientUuid, billingDate]);
+
+  function onLoadingClaimVisit(claimVisit: ClaimsVisit) {
+    if (claimVisit) {
+      setClaimsVisit(claimVisit);
+    }
+  }
+
+  async function getPatientPayments() {
+    const patientPaymentPayload = getPatientPaymentsPayload();
+    try {
+      const resp = await fetchPatientBillPayments(patientPaymentPayload);
+      if (resp && resp.length > 0) {
+        setPatientBillPayments(resp);
+      } else {
+        setPatientBillPayments([]);
+      }
+    } catch (error) {
+      showSnackbar({
+        title: 'Error fetching patient bill payments',
+        kind: 'error',
+        subtitle: 'An error occurred while fetching the patient bill payments',
+      });
+    }
+  }
+  function getPatientPaymentsPayload(): PatientPaymentsDto {
+    return {
+      patientUuid: patientUuid,
+      billingDate: billingDate,
+    };
+  }
+
+  async function getPatientAmrsVisitDiagnosis() {
+    setVisitDiagnosisLoading(true);
+    const amrsVisitDiagnosisPayload = getPatientAmrsVisitDiagnosisPayload();
+    try {
+      const resp = await fetchPatientDiagnosis(amrsVisitDiagnosisPayload);
+      setVisitDiagnosis(resp ?? []);
+    } catch (error) {
+      showSnackbar({
+        title: 'Error fetching patient diagnosis',
+        kind: 'error',
+        subtitle: 'An error occurred while fetching the patient diagnosis',
+      });
+    } finally {
+      setVisitDiagnosisLoading(false);
+    }
+  }
+  async function getPatientAmrsMaternityDiagnosis() {
+    setMaternityDiagnosisLoading(true);
+    const amrsMaternityDiagnosisPayload = getPatientAmrsMaternityDiagnosisPayload();
+    try {
+      const resp: any = await fetchMaternityDiagnosis(amrsMaternityDiagnosisPayload);
+      const results = (resp ?? [])
+        .filter((r) => r?.uuid != null)
+        .map((v) => ({ ...v, practitioner_identifier_type: 'National ID' }));
+      setMaternityDiagnosis(results);
+    } catch (error) {
+      showSnackbar({
+        title: 'Error fetching patient maternity diagnosis',
+        kind: 'error',
+        subtitle: 'An error occurred while fetching the patient maternity diagnosis',
+      });
+    } finally {
+      setMaternityDiagnosisLoading(false);
+    }
+  }
+  async function getPatientAmrsEncounterDiagnosis() {
+    setEncounterDiagnosisLoading(true);
+    const amrsMaternityDiagnosisPayload = getPatientAmrsVisitDiagnosisPayload();
+    try {
+      const resp: any = await fetchPatientEncounterDiagnosis(amrsMaternityDiagnosisPayload);
+      const results = (resp ?? []).filter((r) => r?.uuid != null && r?.dx_rank === 2).map((v) => ({ ...v }));
+      setEncounterDiagnosis(results);
+    } catch (error) {
+      showSnackbar({
+        title: 'Error fetching patient encounter diagnosis',
+        kind: 'error',
+        subtitle: 'An error occurred while fetching the patient encounter diagnosis',
+      });
+    } finally {
+      setEncounterDiagnosisLoading(false);
+    }
+  }
+  function getPatientAmrsVisitDiagnosisPayload(): AmrsVisitDiagnosisDto {
+    return {
+      patientUuid: patientUuid,
+      visitDate: billingDate,
+      locationUuid: locationUuid,
+    };
+  }
+  function getPatientAmrsMaternityDiagnosisPayload(): AmrsMaternityDiagnosisDto {
+    return {
+      patientUuid: patientUuid,
+      billingDate: billingDate,
+    };
+  }
+
+  if (isLoading && !patientBillDetails) {
+    return <InlineLoading description="Loading bill details ..." />;
+  }
+
+  if (isValidating && !patientBillDetails) {
+    return <InlineLoading description="Refreshing bill details ..." />;
+  }
+
+  function formatVisitDate(visitDateTime: string){
+      if(!visitDateTime){
+         return '';
+      }
+      return new Date(visitDateTime).toISOString().slice(0, 16).replace('T', ' ') ?? '';
+  }
+
+  return (
+    <>
+      <div className={styles.visitDetailsLayout}>
+        <RadioButtonGroup name="patient-visits" onChange={handVisitTypeChange} defaultSelected={selectedVisitUuid}>
+          {patientVisits &&
+            patientVisits?.map((v) => {
+              return (
+                <RadioButton id={v.visit_uuid} labelText={`${v.visit_type}: ${formatVisitDate(v.date_started)}`} value={v.visit_uuid} />
+              );
+            })}
+        </RadioButtonGroup>
+        {selectedVisitUuid && (
+          <Tabs>
+            <TabList scrollDebounceWait={200}>
+              <Tab>Bill Details</Tab>
+              <Tab>Claim</Tab>
+            </TabList>
+            <TabPanels>
+              <TabPanel>
+                {patientBillDetails && (
+                  <BillDetails
+                    patientBillDetails={patientBillDetails}
+                    patientPayments={patientBillPayments}
+                    amrsVisitDiagnosis={patientAmrsVisitDiagnosis}
+                    locationUuid={locationUuid}
+                    consentToken={consentToken}
+                    claimsVisit={claimsVisit}
+                  />
+                )}
+              </TabPanel>
+              <TabPanel>
+                {locationUuid && consentToken ? (
+                  <PatientClaimDetails
+                    locationUuid={locationUuid}
+                    patientBillDetails={patientBillDetails}
+                    consentToken={consentToken ?? ''}
+                    onBillDetailsChange={() => invalidatePatientBillDetails()}
+                    billingDate={billingDate}
+                    onLoadingClaimVisit={onLoadingClaimVisit}
+                    patientUuid={patientUuid}
+                  />
+                ) : (
+                  <></>
+                )}
+              </TabPanel>
+            </TabPanels>
+          </Tabs>
+        )}
+      </div>
+    </>
+  );
+};
+
+export default PatientVisitDetailsComponent;

package/src/billing/dashboard/v3/patient-bill-details/patient-visit.scss

@@ -0,0 +1,9 @@
+.radioButton {
+    margin: 2rem;
+}
+.visitDetailsLayout{
+    display: flex;
+    flex-direction: column;
+    row-gap: 5px;
+    margin-top: 10px;
+}

package/src/billing/dashboard/v3/patient-bill-details/visit-diagnosis-details/visit-diagnosis-details.component.tsx

@@ -0,0 +1,102 @@
+import React, { useState } from "react";
+import styles from './visit-diagnosis-details.component.scss';
+import { type AmrsVisitDiagnosis } from "../../../../types";
+import { Button, OverflowMenu, OverflowMenuItem, Table, TableBody, TableCell, TableHead, TableHeader, TableRow, Tag } from "@carbon/react";
+import { formatDate, parseDate } from "@openmrs/esm-framework";
+import AddClaimDiagnosisModal from "../modals/add-claim-diagnosis/add-claim-diagnosis.modal";
+import { useInvalidateProviderClaimPreview } from "../../../../billing-claims.resource";
+import { type ClaimsVisit } from "../../types";
+
+interface visitDiagnosisDetailsProps {
+  amrsVisitDiagnosis: AmrsVisitDiagnosis[];
+  consentToken: string;
+  interventionCode: string;
+  locationUuid: string;
+  claimsVisit: ClaimsVisit;
+}
+const VisitDiagnosisDetails: React.FC<visitDiagnosisDetailsProps> = ({ amrsVisitDiagnosis, consentToken, interventionCode, locationUuid, claimsVisit }) => {
+  const [selectedAmrsDiagnosis, setSelectedAmrsDiagnosis] = useState<AmrsVisitDiagnosis | null>(null);
+  const [showAddClaimDiagnosisModal, setShowAddClaimDiagnosisModal] = useState<boolean>(false);
+  const invalidateProviderClaimPreview = useInvalidateProviderClaimPreview();
+
+  function handleCloseModal() {
+    setShowAddClaimDiagnosisModal(false);
+  }
+  function handleDiagnosisSelection(amrsVisitDiagnosis: AmrsVisitDiagnosis) {
+    setSelectedAmrsDiagnosis(amrsVisitDiagnosis);
+    setShowAddClaimDiagnosisModal(true);
+  }
+  function onSuccess() {
+    handleCloseModal();
+    invalidateProviderClaimPreview();
+  }
+  const diagnosisAddedToClaim = (d: AmrsVisitDiagnosis): boolean => {
+    // Check if diagnosis is already added to the claim
+    if (!claimsVisit?.claim_diagnoses) return false;
+    return claimsVisit.claim_diagnoses.some(
+      (cd) => cd.diagnosis_code === d.icd11_code
+    );
+  };
+  return <>
+    <div>
+      <Table aria-label="diagnoses" size="sm">
+        <TableHead>
+          <TableRow>
+            <TableHeader>No</TableHeader>
+            <TableHeader>Encounter Date</TableHeader>
+            <TableHeader>Encounter Type</TableHeader>
+            <TableHeader>ICD11 Diagnosis</TableHeader>
+            <TableHeader>Diagnosis Name</TableHeader>
+            <TableHeader>Diagnosis Type</TableHeader>
+            <TableHeader>Practitioner</TableHeader>
+            <TableHeader>Practitioner Speciality</TableHeader>
+            <TableHeader>Regulatory Body</TableHeader>
+            <TableHeader>Actions</TableHeader>
+          </TableRow>
+        </TableHead>
+        <TableBody>
+          {amrsVisitDiagnosis &&
+            amrsVisitDiagnosis.map((d, index) => {
+              return (
+                <>
+                  <TableRow key={d.encounter_id}>
+                    <TableCell>{index + 1}</TableCell>
+                    <TableCell>{formatDate(parseDate(d.encounter_datetime))}</TableCell>
+                    <TableCell>{d.encounter_type}</TableCell>
+                    <TableCell>{d.icd11_code}</TableCell>
+                    <TableCell>{d?.concept_name}</TableCell>
+                    <TableCell>{d?.diagnosis_type}</TableCell>
+                    <TableCell>{d?.provider_name}</TableCell>
+                    <TableCell>{d?.practitioner_speciality}</TableCell>
+                    <TableCell>{d?.practitioner_body}</TableCell>
+                    <TableCell>
+                      {claimsVisit && claimsVisit.workflow_state === 'DRAFT' && !diagnosisAddedToClaim(d) && (
+                        <Button size="sm" kind="tertiary" onClick={() => handleDiagnosisSelection(d)}>Add Claim Diagnosis</Button>
+                      )}
+                      {claimsVisit && claimsVisit.workflow_state !== 'DRAFT' && (
+                        <Tag>{claimsVisit.workflow_state}</Tag>
+                      )}
+                    </TableCell>
+                  </TableRow>
+                </>
+              );
+            })}
+        </TableBody>
+      </Table>
+
+      {
+        (showAddClaimDiagnosisModal && selectedAmrsDiagnosis) &&
+        <AddClaimDiagnosisModal
+          consentToken={consentToken}
+          amrsVisitDiagnosis={selectedAmrsDiagnosis}
+          locationUuid={locationUuid}
+          interventionCode={interventionCode}
+          open={showAddClaimDiagnosisModal}
+          onClose={handleCloseModal}
+          onSuccess={onSuccess}
+        />
+      }
+    </div>
+  </>
+}
+export default VisitDiagnosisDetails;

package/src/billing/dashboard/v3/preauth/elective/elective-authorize.resource.ts

@@ -0,0 +1,284 @@
+/**
+ * Elective (pre-visit) authorization helpers — Scenario 4 Phase 2.
+ *
+ * Kept separate from normal / day-of visit consent in `registry/hie.resource.ts`
+ * so elective Raise changes do not alter triage / claim-visit OTP flows.
+ *
+ * @see https://hie-docs.dha.go.ke/docs/scenarios/scenario-4-shif-op-ffs-elective-preauth
+ */
+import { openmrsFetch } from '@openmrs/esm-framework';
+import { getHieBaseUrl } from '../../../../../shared/utils/get-base-url';
+import {
+  createPreauth,
+  extractHieErrorMessage,
+  type PreauthFormPayload,
+} from '../../../../../claims/claims.resource';
+import type { Intervention } from '../../../../../claims/index';
+import type { PatientContactResponse, PatientContactResult } from '../../../../../registry/hie.types';
+import { getAuthorizations } from '../../../../../registry/hie.resource';
+import type { Authorization } from '../../../../../registry/hie.types';
+
+export type ElectiveAuthorizationResult = {
+  token?: string;
+  guid?: string;
+  status?: string;
+  [key: string]: unknown;
+};
+
+const PREVISIT_REUSABLE = new Set(['AUTHORIZED_PENDING_VISIT']);
+
+function unwrapAuthorizeError(data: any, status: number): string {
+  const raw = data?.message || data?.error || data?.details || 'Failed to authorize elective preauth';
+  let errorText =
+    typeof raw === 'string'
+      ? raw
+      : Array.isArray(raw)
+        ? raw.join('; ')
+        : `Request failed with ${status}`;
+  try {
+    const nested = JSON.parse(errorText);
+    if (nested?.error) {
+      errorText = Array.isArray(nested.error) ? nested.error.join('; ') : String(nested.error);
+    } else if (typeof nested === 'string') {
+      errorText = nested;
+    }
+  } catch {
+    const m = errorText.match(/could not create the authorization:\s*(\{[\s\S]*\})\s*$/i);
+    if (m?.[1]) {
+      try {
+        const inner = JSON.parse(m[1]);
+        if (Array.isArray(inner?.error)) errorText = inner.error.join('; ');
+      } catch {
+        /* keep */
+      }
+    }
+  }
+  return errorText;
+}
+
+/** Phase 2 step 6a — GET /api/v1/patients/contacts (via hie-saf). */
+export async function fetchElectivePatientContacts(
+  patientId: string,
+  locationUuid: string,
+): Promise<PatientContactResult[]> {
+  const hieBaseUrl = await getHieBaseUrl();
+  const url = `${hieBaseUrl}/client/contacts`;
+  const response = await openmrsFetch(url, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ crId: patientId, locationUuid }),
+  });
+
+  const data =
+    typeof (response as any)?.json === 'function'
+      ? await (response as any).json()
+      : ((response as any)?.data ?? response);
+
+  if (!(response as any).ok && (response as any).status >= 400) {
+    throw new Error(data?.message || 'Failed to fetch patient contacts');
+  }
+
+  const typed = data as PatientContactResponse | PatientContactResult[];
+  const rows = Array.isArray((typed as PatientContactResponse)?.results)
+    ? (typed as PatientContactResponse).results
+    : Array.isArray(typed)
+      ? typed
+      : [];
+  return rows.filter((c) => c && c.active !== false);
+}
+
+/**
+ * Phase 2 step 7a — POST /api/v1/claims/otp.
+ * Optional beneficiary_contact_id after contact confirmation.
+ */
+export async function sendElectivePreauthOtp(params: {
+  patientId: string;
+  locationUuid: string;
+  interventionCode: string;
+  beneficiaryContactId?: string;
+}): Promise<unknown> {
+  const patientId = String(params.patientId ?? '').trim();
+  const locationUuid = String(params.locationUuid ?? '').trim();
+  const interventionCode = String(params.interventionCode ?? '').trim();
+  if (!patientId || !locationUuid || !interventionCode) {
+    throw new Error('Missing patient, location, or intervention for elective OTP');
+  }
+
+  // Intentionally does not call cancelAllPendingAuthorizations — Raise/elective OTP
+  // must not wipe in-flight claim authorizations for this beneficiary.
+
+  const hieBaseUrl = await getHieBaseUrl();
+  const body: Record<string, unknown> = {
+    intervention_codes: [interventionCode],
+    patient_id: patientId,
+    locationUuid,
+  };
+  const contactId = String(params.beneficiaryContactId ?? '').trim();
+  if (contactId) {
+    body.beneficiary_contact_id = contactId;
+  }
+
+  const response = await openmrsFetch(`${hieBaseUrl}/claims-otp`, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  });
+
+  const data =
+    typeof (response as any)?.json === 'function'
+      ? await (response as any).json()
+      : ((response as any)?.data ?? response);
+
+  if (!(response as any).ok && (response as any).status >= 400) {
+    throw new Error(data?.message || `Failed to send elective OTP (${(response as any).status})`);
+  }
+
+  return data;
+}
+
+/**
+ * Phase 2 step 8a — POST /api/v1/claims/authorize (pre-visit).
+ *
+ * Body: patient_id, otp, interventions, service_type (+ optional contact).
+ * Do NOT send is_elective — HIE treats that as day-of visit needing FINALISED preauth.
+ * Expect AUTHORIZED_PENDING_VISIT; use `token` as consent_token for POST /preauths.
+ */
+export async function authorizeElectivePreauthWithOtp(params: {
+  patientId: string;
+  otp: string;
+  interventions: string[];
+  serviceType: string;
+  locationUuid: string;
+  beneficiaryContactId?: string;
+}): Promise<ElectiveAuthorizationResult> {
+  const hieBaseUrl = await getHieBaseUrl();
+  const body: Record<string, unknown> = {
+    patient_id: params.patientId,
+    otp: params.otp,
+    interventions: params.interventions,
+    service_type: params.serviceType,
+    locationUuid: params.locationUuid,
+  };
+  const contactId = String(params.beneficiaryContactId ?? '').trim();
+  if (contactId) {
+    body.beneficiary_contact_id = contactId;
+  }
+
+  const response = await openmrsFetch(`${hieBaseUrl}/claims-authorize`, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  });
+
+  const data =
+    typeof (response as any)?.json === 'function'
+      ? await (response as any).json()
+      : ((response as any)?.data ?? response);
+
+  if (!(response as any).ok && (response as any).status >= 400) {
+    throw new Error(unwrapAuthorizeError(data, (response as any).status ?? 400));
+  }
+
+  const nested = data?.data && typeof data.data === 'object' ? data.data : data;
+  return (nested ?? {}) as ElectiveAuthorizationResult;
+}
+
+/**
+ * Prefer an existing open AUTHORIZED_PENDING_VISIT for this CR.
+ *
+ * Calling /claims/authorize again while such a token exists makes HIE treat the
+ * request as a day-of "elective visit" and fail with
+ * "no active approved preauth … for elective visit with consent token …".
+ */
+export async function findReusableElectivePreVisitAuthorization(
+  patientId: string,
+  locationUuid: string,
+): Promise<Authorization | null> {
+  const cr = String(patientId ?? '').trim();
+  const loc = String(locationUuid ?? '').trim();
+  if (!cr || !loc) return null;
+
+  try {
+    const auths = await getAuthorizations(loc, cr, undefined);
+    const reusable = (auths ?? []).filter((a) => {
+      const status = String(a?.status ?? '').trim().toUpperCase();
+      const token = String(a?.token ?? '').trim();
+      if (!token || !PREVISIT_REUSABLE.has(status)) return false;
+      if (a.isOpen === false) return false;
+      return true;
+    });
+    return reusable[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve pre-visit consent for elective Raise:
+ * 1) reuse AUTHORIZED_PENDING_VISIT if already open for this beneficiary
+ * 2) otherwise mint a new one via OTP authorize (Phase 2 step 8a)
+ */
+export async function resolveOrCreateElectivePreVisitAuthorization(params: {
+  patientId: string;
+  otp: string;
+  interventions: string[];
+  serviceType: string;
+  locationUuid: string;
+  beneficiaryContactId?: string;
+}): Promise<ElectiveAuthorizationResult> {
+  const existing = await findReusableElectivePreVisitAuthorization(
+    params.patientId,
+    params.locationUuid,
+  );
+  if (existing?.token) {
+    return {
+      token: existing.token,
+      status: existing.status,
+      guid: existing.guid,
+      reused: true,
+    };
+  }
+
+  return authorizeElectivePreauthWithOtp(params);
+}
+
+export function extractElectiveAuthorizationToken(auth: ElectiveAuthorizationResult | null | undefined): string {
+  if (!auth) return '';
+  return String(
+    auth.token ?? (auth as any).consent_token ?? (auth as any).consentToken ?? '',
+  ).trim();
+}
+
+/**
+ * Create elective preauth via the same HIE multipart gateway as normal
+ * (`POST /pre-auth/normal` → HIE `/preauths`), but only called from elective Raise.
+ * Isolated so we can diverge payload / polling later without touching normal Raise.
+ */
+export async function createElectivePreauth(
+  payload: PreauthFormPayload,
+  intervention: Pick<
+    Intervention,
+    | 'code'
+    | 'requiresRadiologyPreauth'
+    | 'requiresOncologyPreauth'
+    | 'requiresOpticalPreauth'
+    | 'requiresRenalPreauth'
+    | 'requiresSurgicalPreauth'
+  >,
+  consentToken: string,
+) {
+  try {
+    return await createPreauth(payload, intervention, consentToken);
+  } catch (e) {
+    throw extractHieErrorMessage(e, 'Failed to create elective preauth');
+  }
+}