@rinse-dental/open-dental 0.0.6 → 0.1.0

package/src/api/patients.ts

@@ -1,26 +1,205 @@
+import axios from "axios";
 import HttpClient from "../utils/httpClient";
-import { Patient } from "../utils/types";
+import {
+  Patient,
+  PatientSummary,
+  GetPatientsParams,
+  CreatePatientParams,
+  UpdatePatientParams,
+} from "../types/patientTypes";
 
-export interface IPatients {
-  getPatient(params: { PatNum: number }): Promise<Patient>;
-  getPatients(): Promise<Patient[]>;
-}
-
-export default class Patients implements IPatients {
+export default class Patients {
   private httpClient: HttpClient;
 
   constructor(httpClient: HttpClient) {
     this.httpClient = httpClient;
   }
 
-  public async getPatient(params: { PatNum: number }): Promise<Patient> {
-    if (!params.PatNum) {
-      throw new Error("PatNum is required.");
+  /**
+   * Fetch a single patient by their ID.
+   * @param {number} PatNum - The ID of the patient.
+   * @returns {Promise<Patient>} - The patient data.
+   * @throws {Error} - If `PatNum` is not valid or the API returns an error.
+   */
+  public async getPatient(PatNum: number): Promise<Patient> {
+    if (!PatNum || typeof PatNum !== "number") {
+      throw new Error("Invalid parameter: PatNum must be a valid number.");
+    }
+
+    return await this.httpClient.get<Patient>(`/patients/${PatNum}`);
+  }
+
+  /**
+   * Fetch multiple patients with optional filtering and pagination.
+   * @param {Object} params - Filtering and pagination parameters.
+   * @param {string} [params.LName] - Filter by last name (case-insensitive, partial match).
+   * @param {string} [params.FName] - Filter by first name (case-insensitive, partial match).
+   * @param {string} [params.Phone] - Filter by phone number.
+   * @param {string} [params.Address] - Filter by primary address.
+   * @param {'true' | 'false'} [params.hideInactive] - Exclude inactive patients.
+   * @param {string} [params.City] - Filter by city.
+   * @param {string} [params.State] - Filter by state.
+   * @param {string} [params.SSN] - Filter by Social Security Number.
+   * @param {string} [params.ChartNumber] - Filter by chart number.
+   * @param {'true' | 'false'} [params.guarOnly] - Limit results to guarantors only.
+   * @param {'true' | 'false'} [params.showArchived] - Include archived patients.
+   * @param {string} [params.Birthdate] - Filter by birthdate in "yyyy-MM-dd" format.
+   * @param {number} [params.SiteNum] - Filter by site number.
+   * @param {string} [params.SubscriberId] - Filter by subscriber ID.
+   * @param {string} [params.Email] - Filter by email address.
+   * @param {string} [params.Country] - Filter by country.
+   * @param {number} [params.ClinicNum] - Filter by clinic number (comma-separated list).
+   * @param {string} [params.clinicAbbr] - Filter by clinic abbreviation.
+   * @param {string} [params.invoiceNumber] - Filter by invoice number.
+   * @param {number} [params.Offset] - Pagination offset.
+   * @returns {Promise<PatientSummary[]>} - A list of summarized patient data.
+   * @throws {Error} - If the API returns an error.
+   */
+    public async getPatients({
+      LName,
+      FName,
+      Phone,
+      Address,
+      hideInactive,
+      City,
+      State,
+      SSN,
+      ChartNumber,
+      guarOnly,
+      showArchived,
+      Birthdate,
+      SiteNum,
+      SubscriberId,
+      Email,
+      Country,
+      ClinicNum,
+      clinicAbbr,
+      invoiceNumber,
+      Offset,
+    }: GetPatientsParams = {}): Promise<PatientSummary[]> {
+
+      return await this.httpClient.get<PatientSummary[]>("/patients", {
+        LName,
+        FName,
+        Phone,
+        Address,
+        hideInactive,
+        City,
+        State,
+        SSN,
+        ChartNumber,
+        guarOnly,
+        showArchived,
+        Birthdate,
+        SiteNum,
+        SubscriberId,
+        Email,
+        Country,
+        ClinicNum,
+        clinicAbbr,
+        invoiceNumber,
+        Offset,
+      });
+
     }
-    return this.httpClient.get<Patient>(`/patients/${params.PatNum}`);
+
+  /**
+   * Create a new patient.
+   * @param {Object} data - The data for the new patient.
+   * @param {string} data.LName - Required: Last name.
+   * @param {string} data.FName - Required: First name.
+   * @param {string} [data.MiddleI] - Optional: Middle initial.
+   * @param {string} [data.Preferred] - Optional: Preferred name.
+   * @param {'Patient' | 'NonPatient' | 'Inactive' | 'Archived' | 'Deceased' | 'Prospective'} [data.PatStatus="Patient"] - Optional: Patient status. Default is "Patient".
+   * @param {'Male' | 'Female' | 'Unknown' | 'Other'} [data.Gender] - Optional: Gender.
+   * @param {'Single' | 'Married' | 'Child' | 'Widowed' | 'Divorced'} [data.Position] - Optional: Marital status.
+   * @param {string} [data.Birthdate] - Optional: Birthdate in "yyyy-MM-dd" format.
+   * @param {string} [data.SSN] - Optional: Social Security Number.
+   * @param {string} [data.Address] - Optional: Primary address.
+   * @param {string} [data.Address2] - Optional: Secondary address.
+   * @param {string} [data.City] - Optional: City.
+   * @param {string} [data.State] - Optional: State.
+   * @param {string} [data.Zip] - Optional: ZIP code.
+   * @param {string} [data.HmPhone] - Optional: Home phone number.
+   * @param {string} [data.WkPhone] - Optional: Work phone number.
+   * @param {string} [data.WirelessPhone] - Optional: Mobile phone number.
+   * @param {number} [data.Guarantor] - Optional: Guarantor's PatNum.
+   * @param {string} [data.Email] - Optional: Email address.
+   * @param {number} [data.PriProv] - Optional: Primary provider number.
+   * @param {number} [data.SecProv] - Optional: Secondary provider number.
+   * @param {string} [data.BillingType] - Optional: Billing type description.
+   * @param {string} [data.FamFinUrgNote] - Optional: Family financial urgent note.
+   * @returns {Promise<Patient>} - The created patient.
+   * @throws {Error} - If the data is invalid or the API returns an error.
+   */
+  public async createPatient({
+    LName,
+    FName,
+    ...optionalData
+  }: CreatePatientParams): Promise<Patient> {
+    if (!LName || !FName) {
+      throw new Error("Invalid data: LName and FName are required.");
+    }
+    return await this.httpClient.post<Patient>("/patients", {
+      LName,
+      FName,
+      ...optionalData,
+    });
   }
 
-  public async getPatients(): Promise<Patient[]> {
-    return this.httpClient.get<Patient[]>("/patients");
+ /**
+ * Update an existing patient.
+ * @param {number} PatNum - Required: The unique identifier of the patient to update.
+ * @param {Object} data - Required: The updated patient data.
+ * @param {string} [data.LName] - Optional: Last name.
+ * @param {string} [data.FName] - Optional: First name.
+ * @param {string} [data.MiddleI] - Optional: Middle initial.
+ * @param {string} [data.Preferred] - Optional: Preferred name.
+ * @param {'Patient' | 'NonPatient' | 'Inactive' | 'Archived' | 'Deceased' | 'Prospective'} [data.PatStatus] - Optional: Patient status.
+ * @param {'Male' | 'Female' | 'Unknown' | 'Other'} [data.Gender] - Optional: Gender.
+ * @param {'Single' | 'Married' | 'Child' | 'Widowed' | 'Divorced'} [data.Position] - Optional: Marital status.
+ * @param {string} [data.Birthdate] - Optional: Birthdate in "yyyy-MM-dd" format.
+ * @param {string} [data.SSN] - Optional: Social Security Number.
+ * @param {string} [data.Address] - Optional: Primary address.
+ * @param {string} [data.Address2] - Optional: Secondary address.
+ * @param {string} [data.City] - Optional: City.
+ * @param {string} [data.State] - Optional: State.
+ * @param {string} [data.Zip] - Optional: ZIP code.
+ * @param {string} [data.HmPhone] - Optional: Home phone number.
+ * @param {string} [data.WkPhone] - Optional: Work phone number.
+ * @param {string} [data.WirelessPhone] - Optional: Mobile phone number.
+ * @param {number} [data.Guarantor] - Optional: Guarantor's PatNum.
+ * @param {string} [data.Email] - Optional: Email address.
+ * @param {number} [data.PriProv] - Optional: Primary provider number.
+ * @param {number} [data.SecProv] - Optional: Secondary provider number.
+ * @param {string} [data.BillingType] - Optional: Billing type description.
+ * @param {string} [data.FamFinUrgNote] - Optional: Family financial urgent note.
+ * @param {string} [data.ChartNumber] - Optional: Chart number.
+ * @param {string} [data.DateFirstVisit] - Optional: Date of first visit in "yyyy-MM-dd" format.
+ * @param {number} [data.ClinicNum] - Optional: Clinic number.
+ * @param {string} [data.Ward] - Optional: Ward.
+ * @param {'None' | 'Email' | 'TextMessage' | 'PhoneCall' | 'Mail'} [data.PreferConfirmMethod] - Optional: Preferred confirmation method.
+ * @param {'None' | 'Email' | 'TextMessage' | 'PhoneCall' | 'Mail'} [data.PreferContactMethod] - Optional: Preferred contact method.
+ * @param {'None' | 'Email' | 'TextMessage' | 'PhoneCall' | 'Mail'} [data.PreferRecallMethod] - Optional: Preferred recall method.
+ * @param {string} [data.Language] - Optional: Language code in ISO 639-2 format.
+ * @param {string} [data.AdmitDate] - Optional: Admission date in "yyyy-MM-dd" format.
+ * @param {number} [data.SuperFamily] - Optional: Super family number.
+ * @param {'Unknown' | 'Yes' | 'No'} [data.TxtMsgOk] - Optional: Text message consent.
+ * @returns {Promise<Patient>} - The updated patient.
+ * @throws {Error} - If the parameters are invalid or the API returns an error.
+ */
+  public async updatePatient(PatNum: number, data: UpdatePatientParams): Promise<Patient> {
+    // Validate required parameters
+    if (!PatNum || typeof PatNum !== "number") {
+      throw new Error("Invalid parameter: PatNum must be a valid number.");
+    }
+
+    if (!data || Object.keys(data).length === 0) {
+      throw new Error("Invalid data: Update data cannot be empty.");
+    }
+
+    return await this.httpClient.put<Patient>(`/patients/${PatNum}`, data);
+
   }
+
 }

package/src/api/procedureLog.ts

@@ -0,0 +1,230 @@
+import HttpClient from "../utils/httpClient";
+import {
+  ProcedureLog,
+  createProcedureLogParams,
+  updateProcedureLogParams,
+  InsuranceHistory,
+  getInsuranceHistoryParams,
+  postInsuranceHistoryParams,
+} from "../types/procedurelogTypes";
+
+export default class ProcedureLogs {
+  private httpClient: HttpClient;
+
+  constructor(httpClient: HttpClient) {
+    this.httpClient = httpClient;
+  }
+
+  /**
+   * Fetch a specific procedure log entry by its ID.
+   * @param {number} ProcNum - Required: The unique identifier of the procedure log.
+   * @returns {Promise<ProcedureLog>} - The procedure log details.
+   * @throws {Error} - If `ProcNum` is not valid or the API returns an error.
+   */
+  public async getProcedureLog(ProcNum: number): Promise<ProcedureLog> {
+    if (!ProcNum || typeof ProcNum !== "number") {
+      throw new Error("Invalid parameter: ProcNum must be a valid number.");
+    }
+
+    return this.httpClient.get<ProcedureLog>(`/procedurelogs/${ProcNum}`);
+  }
+
+  /**
+   * Create a new procedure log entry.
+   * @param {Object} params - The details of the procedure log to create.
+   * @param {number} params.PatNum - Required: Patient number.
+   * @param {string} params.ProcDate - Required: Procedure date in "yyyy-MM-dd" format.
+   * @param {'TP' | 'C' | 'EO'} params.ProcStatus - Required: Procedure status.
+   * @param {string} params.procCode - Required: Procedure code (D code).
+   * @param {number} [params.AptNum] - Optional: Associated appointment number.
+   * @param {number} [params.ProcFee] - Optional: Fee for the procedure.
+   * @param {Surf} [Surf] - Optional: Tooth surface or treatment area. Options include:
+    * - "B/F" (Buccal/Facial)
+    * - "V" (Vestibular)
+    * - "M" (Mesial)
+    * - "O/I" (Occlusal/Incisal)
+    * - "D" (Distal)
+    * - "L" (Lingual)
+    * - "UL" (Upper Left Quadrant)
+    * - "UR" (Upper Right Quadrant)
+    * - "LR" (Lower Right Quadrant)
+    * - "LL" (Lower Left Quadrant)
+    * - "1" (Sextant 1)
+    * - "2" (Sextant 2)
+    * - "3" (Sextant 3)
+    * - "4" (Sextant 4)
+    * - "5" (Sextant 5)
+    * - "6" (Sextant 6)
+    * - "U" (Upper Arch)
+    * - "L" (Lower Arch)
+   * @param {string} [params.ToothNum] - Optional: Tooth number.
+   * @param {string} [params.ToothRange] - Optional: Tooth range.
+   * @param {number} [params.Priority] - Optional: Priority code.
+   * @param {number} [params.ProvNum] - Optional: Provider number.
+   * @param {string} [params.Dx] - Optional: Diagnosis code.
+   * @param {number} [params.PlannedAptNum] - Optional: Planned appointment number.
+   * @param {number} [params.ClinicNum] - Optional: Clinic number.
+   * @returns {Promise<ProcedureLog>} - The created procedure log.
+   * @throws {Error} - If required fields are missing or the API returns an error.
+   */
+  public async createProcedureLog({
+    PatNum,
+    ProcDate,
+    ProcStatus,
+    procCode,
+    ...optionalData
+  }: createProcedureLogParams): Promise<ProcedureLog> {
+    if (!PatNum || !ProcDate || !ProcStatus || !procCode) {
+      throw new Error("Invalid data: PatNum, ProcDate, ProcStatus, and procCode are required.");
+    }
+
+    return this.httpClient.post<ProcedureLog>("/procedurelogs", {
+      PatNum,
+      ProcDate,
+      ProcStatus,
+      procCode,
+      ...optionalData,
+    });
+  }
+
+  /**
+   * Update an existing procedure log entry.
+   * @param {number} ProcNum - Required: The unique identifier of the procedure log to update.
+   * @param {Object} params - The updated details of the procedure log.
+   * @param {string} [params.ProcDate] - Optional: Updated procedure date in "yyyy-MM-dd" format.
+   * @param {number} [params.AptNum] - Optional: Updated associated appointment number.
+   * @param {number} [params.ProcFee] - Optional: Updated fee for the procedure.
+   * @param {number} [params.Priority] - Optional: Updated priority code.
+   * @param {'TP' | 'C' | 'EO'} [params.ProcStatus] - Optional: Updated procedure status.
+   * @param {string} [params.procCode] - Optional: Updated procedure code (D code).
+   * @param {Surf} [Surf] - Optional: Tooth surface or treatment area. Options include:
+    * - "B/F" (Buccal/Facial)
+    * - "V" (Vestibular)
+    * - "M" (Mesial)
+    * - "O/I" (Occlusal/Incisal)
+    * - "D" (Distal)
+    * - "L" (Lingual)
+    * - "UL" (Upper Left Quadrant)
+    * - "UR" (Upper Right Quadrant)
+    * - "LR" (Lower Right Quadrant)
+    * - "LL" (Lower Left Quadrant)
+    * - "1" (Sextant 1)
+    * - "2" (Sextant 2)
+    * - "3" (Sextant 3)
+    * - "4" (Sextant 4)
+    * - "5" (Sextant 5)
+    * - "6" (Sextant 6)
+    * - "U" (Upper Arch)
+    * - "L" (Lower Arch)
+   * @param {string} [params.ToothNum] - Optional: Updated tooth number.
+   * @param {string} [params.ToothRange] - Optional: Updated tooth range.
+   * @param {number} [params.ProvNum] - Optional: Updated provider number.
+   * @param {string} [params.Dx] - Optional: Updated diagnosis code.
+   * @param {number} [params.PlannedAptNum] - Optional: Updated planned appointment number.
+   * @param {number} [params.ClinicNum] - Optional: Updated clinic number.
+   * @returns {Promise<ProcedureLog>} - The updated procedure log.
+   * @throws {Error} - If required fields are missing or the API returns an error.
+   */
+  public async updateProcedureLog(
+    ProcNum: number,
+    {
+      ProcDate,
+      AptNum,
+      ProcFee,
+      Priority,
+      ProcStatus,
+      procCode,
+      Surf,
+      ToothNum,
+      ToothRange,
+      ProvNum,
+      Dx,
+      PlannedAptNum,
+      ClinicNum,
+    }: updateProcedureLogParams
+  ): Promise<ProcedureLog> {
+    if (!ProcNum || typeof ProcNum !== "number") {
+      throw new Error("Invalid parameter: ProcNum must be a valid number.");
+    }
+
+    return this.httpClient.put<ProcedureLog>(`/procedurelogs/${ProcNum}`, {
+      ProcDate,
+      AptNum,
+      ProcFee,
+      Priority,
+      ProcStatus,
+      procCode,
+      Surf,
+      ToothNum,
+      ToothRange,
+      ProvNum,
+      Dx,
+      PlannedAptNum,
+      ClinicNum,
+    });
+  }
+
+  /**
+   * Delete a procedure log entry.
+   * @param {number} ProcNum - Required: The unique identifier of the procedure log to delete.
+   * @returns {Promise<void>} - Resolves when the procedure log is deleted.
+   * @throws {Error} - If `ProcNum` is not valid or the API returns an error.
+   */
+  public async deleteProcedureLog(ProcNum: number): Promise<void> {
+    if (!ProcNum || typeof ProcNum !== "number") {
+      throw new Error("Invalid parameter: ProcNum must be a valid number.");
+    }
+
+    return this.httpClient.delete<void>(`/procedurelogs/${ProcNum}`);
+  }
+
+  /**
+   * Fetch insurance history for a patient.
+   * @param {number} PatNum - Required: The patient number.
+   * @param {number} InsSubNum - Required: The insurance subscription number.
+   * @returns {Promise<InsuranceHistory[]>} - The insurance history details.
+   * @throws {Error} - If required fields are missing or the API returns an error.
+   */
+  public async getInsuranceHistory({
+    PatNum,
+    InsSubNum,
+  }: getInsuranceHistoryParams): Promise<InsuranceHistory[]> {
+    if (!PatNum || !InsSubNum) {
+      throw new Error("Invalid parameters: PatNum and InsSubNum are required.");
+    }
+
+    return this.httpClient.get<InsuranceHistory[]>("/procedurelogs/insurancehistory", {
+      PatNum,
+      InsSubNum,
+    });
+  }
+
+  /**
+   * Add an insurance history entry.
+   * @param {number} PatNum - Required: The patient number.
+   * @param {number} InsSubNum - Required: The insurance subscription number.
+   * @param {"InsHistBWCodes" | "InsHistPanoCodes" | "InsHistExamCodes" | "InsHistProphyCodes" | "InsHistPerioURCodes" | "InsHistPerioULCodes" | "InsHistPerioLRCodes" | "InsHistPerioLLCodes" | "InsHistPerioMaintCodes" | "InsHistDebridementCodes"} insHistPrefName - Required: The insurance history category name.
+   * @param {string} ProcDate - Required: Procedure date in "yyyy-MM-dd" format.
+   * @returns {Promise<InsuranceHistory>} - The created insurance history entry.
+   * @throws {Error} - If required fields are missing or the API returns an error.
+   */
+  public async postInsuranceHistory({
+    PatNum,
+    InsSubNum,
+    insHistPrefName,
+    ProcDate,
+  }: postInsuranceHistoryParams): Promise<InsuranceHistory> {
+    if (!PatNum || !InsSubNum || !insHistPrefName || !ProcDate) {
+      throw new Error(
+        "Invalid data: PatNum, InsSubNum, insHistPrefName, and ProcDate are required."
+      );
+    }
+
+    return this.httpClient.post<InsuranceHistory>("/procedurelogs/insurancehistory", {
+      PatNum,
+      InsSubNum,
+      insHistPrefName,
+      ProcDate,
+    });
+  }
+}

package/src/openDental.ts

@@ -1,6 +1,6 @@
 import HttpClient from "./utils/httpClient";
-import Patients, { IPatients } from "./api/patients";
-import Appointments, { IAppointments } from "./api/appointments";
+import Patients from "./api/patients";
+import Appointments from "./api/appointments";
 
 class OpenDental {
   private static httpClient: HttpClient;
@@ -22,7 +22,7 @@ class OpenDental {
   /**
    * Create a new instance of the Patients API.
    */
-  public static Patients(): IPatients {
+  public static Patients() {
     if (!this.httpClient) {
       throw new Error("OpenDental not initialized. Call OpenDental.initialize() first.");
     }
@@ -32,7 +32,7 @@ class OpenDental {
   /**
    * Create a new instance of the Appointments API.
    */
-  public static Appointments(): IAppointments {
+  public static Appointments() {
     if (!this.httpClient) {
       throw new Error("OpenDental not initialized. Call OpenDental.initialize() first.");
     }