@pritiranjan/hl7v2 0.1.0

package/dist/segments/index.d.ts

@@ -0,0 +1,457 @@
+import { a as HL7Segment, E as EncodingChars, b as HL7Field, M as MessageType } from '../schema-qr-scwmL.js';
+
+/**
+ * Base class for typed HL7 v2 segment accessors.
+ *
+ * Typed segments wrap an {@link HL7Segment} and provide strongly-typed,
+ * documented accessor methods for each field — eliminating the need to
+ * remember field numbers or component positions.
+ *
+ * @example
+ * import { PID } from 'hl7v2/segments';
+ * import { parse, segment } from 'hl7v2';
+ *
+ * const msg = parse(rawString);
+ * const pid = new PID(segment(msg, 'PID'), msg.encoding);
+ *
+ * pid.patientName()   // { family: 'Doe', given: 'John', middle: 'A' }
+ * pid.dateOfBirth()   // Date | undefined
+ * pid.sex()           // 'M' | 'F' | 'O' | 'U' | undefined
+ */
+declare abstract class TypedSegment {
+    protected readonly seg: HL7Segment;
+    protected readonly enc: EncodingChars;
+    constructor(seg: HL7Segment, enc: EncodingChars);
+    /** The raw underlying {@link HL7Segment}. */
+    get raw(): HL7Segment;
+    /** Return the raw field structure at the given 1-based field number. */
+    protected field(num: number): HL7Field | undefined;
+    /**
+     * Extract a scalar string value from the segment.
+     * All arguments are 1-based. Missing elements return `''`.
+     * Escape sequences are decoded automatically.
+     */
+    protected str(fieldNum: number, component?: number, subComponent?: number, repetition?: number): string;
+    /**
+     * Extract a string value from the segment without escape decoding.
+     * Useful when you need to preserve the raw HL7 encoding.
+     */
+    protected rawStr(fieldNum: number, component?: number, subComponent?: number, repetition?: number): string;
+    /** Extract a Date from an HL7 date/time field. Returns `undefined` if empty. */
+    protected date(fieldNum: number, component?: number): Date | undefined;
+    /** Extract a numeric value from a field. Returns `undefined` if empty or non-numeric. */
+    protected num(fieldNum: number, component?: number): number | undefined;
+    /** Return all repetitions of a field as an array of first-component strings. */
+    protected repetitions(fieldNum: number, component?: number): string[];
+}
+
+/** Processing ID values defined in HL7 v2 table 0103. */
+type ProcessingId = 'P' | 'D' | 'T';
+/**
+ * Typed accessor for the MSH (Message Header) segment.
+ *
+ * MSH is mandatory and always the first segment in any HL7 v2 message.
+ * It identifies the message type, version, sender, receiver, and timestamp.
+ *
+ * @example
+ * import { parse, segment } from 'hl7v2';
+ * import { MSH } from 'hl7v2/segments';
+ *
+ * const msg = parse(raw);
+ * const msh = new MSH(segment(msg, 'MSH'), msg.encoding);
+ *
+ * msh.sendingApplication()   // 'HOSPITAL_ADT'
+ * msh.messageType()          // { type: 'ADT', event: 'A01', structure: 'ADT_A01' }
+ * msh.messageControlId()     // 'MSG000001'
+ * msh.version()              // '2.5.1'
+ */
+declare class MSH extends TypedSegment {
+    constructor(seg: HL7Segment, enc: EncodingChars);
+    /** MSH.3 — Sending Application */
+    sendingApplication(): string;
+    /** MSH.4 — Sending Facility */
+    sendingFacility(): string;
+    /** MSH.5 — Receiving Application */
+    receivingApplication(): string;
+    /** MSH.6 — Receiving Facility */
+    receivingFacility(): string;
+    /** MSH.7 — Date/Time of Message */
+    dateTimeOfMessage(): Date | undefined;
+    /** MSH.9 — Message Type (e.g., `{ type: 'ADT', event: 'A01', structure: 'ADT_A01' }`). */
+    messageType(): MessageType;
+    /** MSH.10 — Message Control ID (used for ACK correlation). */
+    messageControlId(): string;
+    /**
+     * MSH.11 — Processing ID.
+     * `'P'` = Production, `'D'` = Debugging, `'T'` = Training.
+     */
+    processingId(): ProcessingId | string;
+    /** MSH.12 — HL7 version (e.g., `'2.5.1'`). */
+    version(): string;
+    /** MSH.15 — Accept Acknowledgement Type. */
+    acceptAcknowledgementType(): string;
+    /** MSH.16 — Application Acknowledgement Type. */
+    applicationAcknowledgementType(): string;
+    /** MSH.17 — Country Code (ISO 3166). */
+    countryCode(): string;
+}
+
+/** Administrative sex codes from HL7 v2 table 0001. */
+type AdministrativeSex = 'M' | 'F' | 'O' | 'U' | 'A' | 'N' | 'C';
+/** A structured patient name following HL7 XPN (Extended Person Name). */
+interface PersonName {
+    /** Family (last) name. */
+    family: string;
+    /** Given (first) name. */
+    given: string;
+    /** Middle name or initial. */
+    middle: string;
+    /** Name suffix (e.g., `'JR'`, `'SR'`, `'III'`). */
+    suffix: string;
+    /** Name prefix (e.g., `'DR'`, `'MR'`, `'MS'`). */
+    prefix: string;
+    /** Degree (e.g., `'MD'`, `'PHD'`). */
+    degree: string;
+}
+/** A structured address following HL7 XAD (Extended Address). */
+interface Address {
+    streetAddress: string;
+    otherDesignation: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    country: string;
+    addressType: string;
+}
+/** A patient identifier from PID.3 (Patient Identifier List). */
+interface PatientIdentifier {
+    /** The identifier value (e.g., MRN, SSN). */
+    id: string;
+    /** Check digit. */
+    checkDigit: string;
+    /** Assigning authority (e.g., `'HOSPITAL'`). */
+    assigningAuthority: string;
+    /** Identifier type code (e.g., `'MR'` = Medical Record, `'PI'` = Patient Internal). */
+    identifierTypeCode: string;
+}
+/**
+ * Typed accessor for the PID (Patient Identification) segment.
+ *
+ * PID carries all core patient demographic information and appears in
+ * virtually every HL7 v2 message type (ADT, ORU, ORM, SIU, etc.).
+ *
+ * @example
+ * import { parse, segment } from 'hl7v2';
+ * import { PID } from 'hl7v2/segments';
+ *
+ * const msg = parse(raw);
+ * const pid = new PID(segment(msg, 'PID'), msg.encoding);
+ *
+ * pid.patientName()        // { family: 'Doe', given: 'John', middle: 'A', ... }
+ * pid.dateOfBirth()        // Date | undefined
+ * pid.sex()                // 'M' | 'F' | ...
+ * pid.patientIdentifiers() // PatientIdentifier[]
+ */
+declare class PID extends TypedSegment {
+    constructor(seg: HL7Segment, enc: EncodingChars);
+    /** PID.1 — Set ID (1-based sequence number within the message). */
+    setId(): number | undefined;
+    /**
+     * PID.3 — Patient Identifier List.
+     *
+     * Returns all patient identifiers (MRN, SSN, national ID, etc.).
+     * Each identifier has its own type code and assigning authority.
+     *
+     * @example
+     * pid.patientIdentifiers()
+     * // [{ id: 'MRN123', assigningAuthority: 'HOSPITAL', identifierTypeCode: 'MR' }]
+     */
+    patientIdentifiers(): PatientIdentifier[];
+    /**
+     * PID.3 — Primary patient identifier (first in the list).
+     * Returns the raw identifier string (e.g., `'MRN123'`).
+     */
+    patientId(): string;
+    /**
+     * PID.5 — Patient Name (first/primary name).
+     *
+     * Patient names follow the XPN (Extended Person Name) data type.
+     * Components: family ^ given ^ middle ^ suffix ^ prefix ^ degree
+     */
+    patientName(): PersonName;
+    /**
+     * PID.5 — All patient names (legal, alias, display, etc.).
+     * Most messages contain a single name; some include aliases or prior names.
+     */
+    allPatientNames(): PersonName[];
+    /**
+     * PID.7 — Date/Time of Birth.
+     * Returns `undefined` if absent or unparseable.
+     */
+    dateOfBirth(): Date | undefined;
+    /**
+     * PID.8 — Administrative Sex (HL7 table 0001).
+     * `'M'` Male · `'F'` Female · `'O'` Other · `'U'` Unknown
+     * `'A'` Ambiguous · `'N'` Not applicable · `'C'` Complex
+     */
+    sex(): AdministrativeSex | string;
+    /**
+     * PID.10 — Race (HL7 table 0005, CWE data type).
+     * Returns the race code (first component).
+     */
+    race(): string;
+    /**
+     * PID.11 — Patient Address (first address).
+     * Addresses follow the XAD (Extended Address) data type.
+     */
+    address(): Address;
+    /** PID.13 — Phone Number - Home (first number, XTN data type). */
+    homePhone(): string;
+    /** PID.14 — Phone Number - Business (first number, XTN data type). */
+    workPhone(): string;
+    /**
+     * PID.15 — Primary Language (CE data type).
+     * Returns the language code (e.g., `'ENG'`, `'SPA'`).
+     */
+    primaryLanguage(): string;
+    /** PID.16 — Marital Status (HL7 table 0002). */
+    maritalStatus(): string;
+    /** PID.17 — Religion (HL7 table 0006). */
+    religion(): string;
+    /**
+     * PID.18 — Patient Account Number.
+     * The billing/visit account number (distinct from the medical record number).
+     */
+    accountNumber(): string;
+    /** PID.19 — SSN Number - Patient (US Social Security Number). */
+    ssn(): string;
+    /** PID.22 — Ethnic Group (HL7 table 0189, CWE data type). */
+    ethnicGroup(): string;
+    /** PID.29 — Patient Death Date and Time. `undefined` if patient is not deceased. */
+    deathDateTime(): Date | undefined;
+    /**
+     * PID.30 — Patient Death Indicator.
+     * `'Y'` = deceased, `'N'` = not deceased.
+     */
+    deathIndicator(): 'Y' | 'N' | string;
+}
+
+/** OBX.2 — Value type codes from HL7 v2 table 0125. */
+type ObservationValueType = 'NM' | 'ST' | 'TX' | 'FT' | 'CWE' | 'CE' | 'DT' | 'TM' | 'TS' | 'DTM' | 'SN' | 'RP' | 'ED' | string;
+/** OBX.11 — Observation Result Status codes from HL7 v2 table 0085. */
+type ResultStatus = 'F' | 'P' | 'C' | 'X' | 'I' | 'R' | 'S' | 'D' | 'N' | 'W' | string;
+/** Abnormal flags from HL7 v2 table 0078. */
+type AbnormalFlag = 'H' | 'HH' | 'L' | 'LL' | 'A' | 'AA' | 'N' | 'IND' | 'NEG' | 'POS' | string;
+/** A coded observation identifier (LOINC, SNOMED, local). */
+interface ObservationIdentifier {
+    /** Identifier code (e.g., LOINC code `'718-7'`). */
+    code: string;
+    /** Human-readable description (e.g., `'Hemoglobin'`). */
+    description: string;
+    /** Coding system (e.g., `'LN'` for LOINC, `'SCT'` for SNOMED CT). */
+    codingSystem: string;
+}
+/**
+ * Typed accessor for the OBX (Observation/Result) segment.
+ *
+ * OBX carries a single clinical observation — a lab result, vital sign,
+ * pathology finding, or any structured clinical measurement. A message
+ * typically contains multiple OBX segments, one per result.
+ *
+ * @example
+ * import { parse, segments } from 'hl7v2';
+ * import { OBX } from 'hl7v2/segments';
+ *
+ * const msg  = parse(raw);
+ * const obxs = segments(msg, 'OBX').map(s => new OBX(s, msg.encoding));
+ *
+ * for (const obx of obxs) {
+ *   console.log(obx.observationIdentifier().description); // 'Hemoglobin'
+ *   console.log(obx.numericValue());                      // 13.5
+ *   console.log(obx.units());                             // 'g/dL'
+ *   console.log(obx.referenceRange());                    // '13.5-17.5'
+ *   console.log(obx.abnormalFlags());                     // ['H']
+ *   console.log(obx.resultStatus());                      // 'F'
+ * }
+ */
+declare class OBX extends TypedSegment {
+    constructor(seg: HL7Segment, enc: EncodingChars);
+    /** OBX.1 — Set ID (sequence number within the message, 1-based). */
+    setId(): number | undefined;
+    /**
+     * OBX.2 — Value Type.
+     * Indicates the data type of the observation value in OBX.5.
+     * Common values: `'NM'` (numeric), `'ST'` (string), `'CWE'` (coded).
+     */
+    valueType(): ObservationValueType;
+    /**
+     * OBX.3 — Observation Identifier.
+     * Typically a LOINC code identifying what was measured.
+     *
+     * @example
+     * obx.observationIdentifier()
+     * // { code: '718-7', description: 'Hemoglobin [Mass/volume] in Blood', codingSystem: 'LN' }
+     */
+    observationIdentifier(): ObservationIdentifier;
+    /** OBX.4 — Observation Sub-ID (groups related OBX segments). */
+    observationSubId(): string;
+    /**
+     * OBX.5 — Observation Value (raw string).
+     *
+     * The interpretation depends on OBX.2 (value type).
+     * Use {@link numericValue} for `NM`, {@link codedValue} for `CWE`/`CE`.
+     */
+    observationValue(): string;
+    /**
+     * OBX.5 — Observation value interpreted as a number.
+     * Returns `undefined` if the value type is not `NM` or the value is absent.
+     *
+     * For structured numerics (SN type like `'>10.5'`), use {@link observationValue}.
+     */
+    numericValue(): number | undefined;
+    /**
+     * OBX.5 — Observation value as a coded element (CWE/CE value type).
+     * Returns `{ code, description, codingSystem }`.
+     */
+    codedValue(): ObservationIdentifier;
+    /**
+     * OBX.6 — Units (CWE data type).
+     * Returns the unit code (e.g., `'g/dL'`, `'10*3/uL'`, `'mmHg'`).
+     */
+    units(): string;
+    /**
+     * OBX.7 — References Range.
+     * The normal range as a string (e.g., `'3.5-5.0'`, `'<200'`).
+     */
+    referenceRange(): string;
+    /**
+     * OBX.8 — Interpretation Codes (formerly Abnormal Flags).
+     * Returns all flags for this result (a field can have multiple repetitions).
+     *
+     * Common values: `'H'` high, `'L'` low, `'HH'` critical high, `'LL'` critical low,
+     * `'N'` normal, `'A'` abnormal, `'POS'` positive, `'NEG'` negative.
+     */
+    abnormalFlags(): AbnormalFlag[];
+    /**
+     * OBX.8 — Primary interpretation code (first flag).
+     * Returns `''` if the result has no flags (i.e., it is normal / in-range).
+     */
+    primaryAbnormalFlag(): AbnormalFlag;
+    /** OBX.11 — Observation Result Status (HL7 table 0085). */
+    resultStatus(): ResultStatus;
+    /** OBX.14 — Date/Time of Observation. */
+    observationDateTime(): Date | undefined;
+    /** OBX.15 — Producer's ID (the lab or device that produced the result). */
+    producerId(): string;
+    /** OBX.16 — Responsible Observer (clinician who verified the result). */
+    responsibleObserver(): string;
+    /** OBX.19 — Date/Time of Analysis. */
+    analysisDateTime(): Date | undefined;
+    /**
+     * Convenience: return `true` if this result has a critical abnormal flag
+     * (`'HH'` or `'LL'`).
+     */
+    isCritical(): boolean;
+    /**
+     * Convenience: return `true` if the result is finalised (`resultStatus() === 'F'`).
+     */
+    isFinal(): boolean;
+}
+
+/** Patient class codes from HL7 v2 table 0004. */
+type PatientClass = 'E' | 'I' | 'O' | 'P' | 'R' | 'B' | 'C' | 'N' | 'U' | string;
+/** A structured provider/clinician name and identifier. */
+interface Provider {
+    /** Provider identifier (e.g., NPI number, employee ID). */
+    id: string;
+    /** Family (last) name. */
+    family: string;
+    /** Given (first) name. */
+    given: string;
+    /** Middle name or initial. */
+    middle: string;
+    /** Credential suffix (e.g., `'MD'`, `'DO'`, `'NP'`). */
+    credential: string;
+}
+/** A patient location — room, bed, facility. */
+interface PatientLocation {
+    pointOfCare: string;
+    room: string;
+    bed: string;
+    facility: string;
+    buildingCode: string;
+    floor: string;
+}
+/**
+ * Typed accessor for the PV1 (Patient Visit) segment.
+ *
+ * PV1 describes the context of a patient's current or historical visit:
+ * the patient class (inpatient/outpatient), assigned location, attending
+ * and referring physicians, and admission/discharge timestamps.
+ *
+ * @example
+ * import { parse, segment } from 'hl7v2';
+ * import { PV1 } from 'hl7v2/segments';
+ *
+ * const msg = parse(raw);
+ * const pv1 = new PV1(segment(msg, 'PV1'), msg.encoding);
+ *
+ * pv1.patientClass()         // 'I' (Inpatient)
+ * pv1.assignedLocation()     // { pointOfCare: 'CARDIOLOGY', room: '4A', bed: '101', ... }
+ * pv1.attendingDoctor()      // { id: '1234567', family: 'Smith', given: 'Richard', ... }
+ * pv1.admitDateTime()        // Date | undefined
+ */
+declare class PV1 extends TypedSegment {
+    constructor(seg: HL7Segment, enc: EncodingChars);
+    /** PV1.1 — Set ID. */
+    setId(): number | undefined;
+    /**
+     * PV1.2 — Patient Class (HL7 table 0004).
+     * `'I'` Inpatient · `'O'` Outpatient · `'E'` Emergency · `'P'` Preadmit
+     */
+    patientClass(): PatientClass;
+    /**
+     * PV1.3 — Assigned Patient Location.
+     * The bed the patient is currently assigned to.
+     */
+    assignedLocation(): PatientLocation;
+    /** PV1.4 — Admission Type (e.g., `'A'` = accident, `'E'` = emergency). */
+    admissionType(): string;
+    /**
+     * PV1.7 — Attending Doctor.
+     * The physician primarily responsible for the patient's care.
+     */
+    attendingDoctor(): Provider;
+    /**
+     * PV1.8 — Referring Doctor.
+     * The physician who referred the patient.
+     */
+    referringDoctor(): Provider;
+    /**
+     * PV1.9 — Consulting Doctor.
+     * Returns all consulting doctors (field can repeat).
+     */
+    consultingDoctors(): Provider[];
+    /** PV1.10 — Hospital Service (e.g., `'MED'`, `'SUR'`, `'CAR'`). */
+    hospitalService(): string;
+    /** PV1.14 — Admit Source (HL7 table 0023). */
+    admitSource(): string;
+    /** PV1.18 — Patient Type. */
+    patientType(): string;
+    /** PV1.19 — Visit Number (account number for this specific visit). */
+    visitNumber(): string;
+    /** PV1.36 — Discharge Disposition (HL7 table 0112). */
+    dischargeDisposition(): string;
+    /**
+     * PV1.44 — Admit Date/Time.
+     * When the patient was admitted to this care setting.
+     */
+    admitDateTime(): Date | undefined;
+    /**
+     * PV1.45 — Discharge Date/Time.
+     * `undefined` if the patient has not yet been discharged.
+     */
+    dischargeDateTime(): Date | undefined;
+}
+
+export { type AbnormalFlag, type Address, type AdministrativeSex, MSH, OBX, type ObservationIdentifier, type ObservationValueType, PID, PV1, type PatientClass, type PatientIdentifier, type PatientLocation, type PersonName, type ProcessingId, type Provider, type ResultStatus, TypedSegment };