@rinse-dental/open-dental 0.0.6 → 0.1.1

package/dist/utils/httpClient.js

@@ -18,17 +18,11 @@ class HttpClient {
     /**
      * GET request
      * @param {string} url - The endpoint URL
-     * @param {object} params - Optional query parameters
+     * @param {object} [params] - Optional query parameters
      * @returns {Promise<T>} - The API response
      */
     async get(url, params) {
-        try {
-            const response = await this.client.get(url, { params });
-            return response.data;
-        }
-        catch (error) {
-            this.handleError(error);
-        }
+        return this.handleRequest(() => this.client.get(url, { params }));
     }
     /**
      * POST request
@@ -37,13 +31,7 @@ class HttpClient {
      * @returns {Promise<T>} - The API response
      */
     async post(url, data) {
-        try {
-            const response = await this.client.post(url, data);
-            return response.data;
-        }
-        catch (error) {
-            this.handleError(error);
-        }
+        return this.handleRequest(() => this.client.post(url, data));
     }
     /**
      * PUT request
@@ -52,13 +40,7 @@ class HttpClient {
      * @returns {Promise<T>} - The API response
      */
     async put(url, data) {
-        try {
-            const response = await this.client.put(url, data);
-            return response.data;
-        }
-        catch (error) {
-            this.handleError(error);
-        }
+        return this.handleRequest(() => this.client.put(url, data));
     }
     /**
      * DELETE request
@@ -66,8 +48,17 @@ class HttpClient {
      * @returns {Promise<T>} - The API response
      */
     async delete(url) {
+        return this.handleRequest(() => this.client.delete(url));
+    }
+    /**
+     * Handles requests and errors consistently across methods.
+     * @param {Function} requestFn - The Axios request function to execute.
+     * @returns {Promise<T>} - The API response or an error message.
+     * @throws {Error} - Throws an error with a formatted message.
+     */
+    async handleRequest(requestFn) {
         try {
-            const response = await this.client.delete(url);
+            const response = await requestFn();
             return response.data;
         }
         catch (error) {
@@ -75,34 +66,35 @@ class HttpClient {
         }
     }
     /**
-     * Error handler to provide detailed error information
-     * @param {AxiosError} error - The error object from Axios
+     * Error handler to provide detailed error information.
+     * @param {unknown} error - The error object from Axios or another source.
+     * @throws {Error} - A formatted error with API details or a general message.
      */
     handleError(error) {
         if (axios_1.default.isAxiosError(error)) {
-            // Handle Axios-specific error
             if (error.response) {
-                // The request was made, and the server responded with a status code
+                // The server responded with a status code outside 2xx
+                const { status, data } = error.response;
                 console.error("API Response Error:", {
-                    status: error.response.status,
-                    data: error.response.data,
+                    status,
+                    data,
                     headers: error.response.headers,
                 });
-                throw new Error(`Request failed with status ${error.response.status}: ${JSON.stringify(error.response.data)}`);
+                throw new Error(`API Error (Status ${status}): ${data?.message || JSON.stringify(data)}`);
             }
             else if (error.request) {
-                // The request was made, but no response was received
+                // The request was made, but no response received
                 console.error("No Response Error:", error.request);
                 throw new Error("No response received from the server.");
             }
             else {
-                // Something happened in setting up the request
+                // Something went wrong in setting up the request
                 console.error("Request Setup Error:", error.message);
                 throw new Error(`Request setup failed: ${error.message}`);
             }
         }
         else {
-            // Handle non-Axios errors
+            // Handle non-Axios-specific errors
             console.error("Unexpected Error:", error);
             throw new Error("An unexpected error occurred.");
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rinse-dental/open-dental",
-    "version": "0.0.6",
+    "version": "0.1.1",
     "description": "A TypeScript library for easily accessing Open Dental APIs.",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",

package/src/api/appointments.ts

@@ -1,40 +1,337 @@
 import HttpClient from "../utils/httpClient";
-import { Appointment } from "../utils/types";
+import {
+  Appointment,
+  AppointmentSlot,
+  GetAppointmentParams,
+  GetASAPParams,
+  GetSlotsParams,
+  GetSlotsWebSchedParams,
+  GetWebSchedAppointmentsParams,
+  CreateNewAppointmentParams,
+  CreatePlannedAppointmentParams,
+  SchedulePlannedAppointmentParams,
+  ScheduleWebSchedAppointmentParams,
+  UpdateAppointmentParams,
+  BreakAppointmentParams,
+  ConfirmAppointmentParams,
+} from "../types/appointmentType";
 
-export interface IAppointments {
-    getAppointment(AptNum: number): Promise<Appointment>;
-    getAppointments(params?: object): Promise<Appointment[]>;
-    createAppointment(data: Partial<Appointment>): Promise<Appointment>;
-  }
+export default class Appointments {
+  private httpClient: HttpClient;
 
-export default class Appointments implements IAppointments {
-    private httpClient: HttpClient;
+  constructor(httpClient: HttpClient) {
+    this.httpClient = httpClient;
+  }
 
-    constructor(httpClient: HttpClient) {
-        this.httpClient = httpClient;
+  /**
+   * Fetch a single appointment by its ID.
+   * @param {number} AptNum - The unique identifier for the appointment.
+   * @returns {Promise<Appointment>} - The appointment object.
+   * @throws {Error} - If `AptNum` is not provided.
+   */
+  public async getAppointment(AptNum: number): Promise<Appointment> {
+    if (!AptNum) {
+      throw new Error("AptNum is required.");
     }
+    return this.httpClient.get<Appointment>(`/appointments/${AptNum}`);
+  }
 
-    /**
-     * Fetch a specific appointment by its ID.
-     * @param {number} AptNum - The ID of the appointment.
-     * @returns {Promise<Appointment>} - The appointment data.
-     * @throws {Error} - If `AptNum` is not provided.
-    */
-    public async getAppointment(AptNum: number): Promise<Appointment> {
-        if (!AptNum) {
-        throw new Error("AptNum is required.");
-        }
-        return this.httpClient.get<Appointment>(`/appointments/${AptNum}`);
+/**
+ * Fetch multiple appointments with optional filtering and pagination.
+ * @param {Object} params - The parameters for filtering and pagination.
+ * @param {number} [params.PatNum] - Filter by patient number.
+ * @param {"Scheduled" | "Complete" | "UnschedList" | "ASAP" | "Broken" | "Planned" | "PtNote" | "PtNoteCompleted"} [params.AptStatus] - Filter by appointment status.
+ * @param {number} [params.Op] - Filter by operatory number.
+ * @param {string} [params.date] - Search for a specific day in "yyyy-MM-dd" format.
+ * @param {string} [params.dateStart] - Start date for date range in "yyyy-MM-dd" format.
+ * @param {string} [params.dateEnd] - End date for date range in "yyyy-MM-dd" format.
+ * @param {number} [params.ClinicNum] - Filter by clinic number.
+ * @param {string} [params.DateTStamp] - Return only appointments updated after this timestamp.
+ * @param {number} [params.Offset] - Pagination offset for results.
+ * @returns {Promise<Appointment[]>} - A list of appointments.
+ */
+public async getAppointments({
+    PatNum,
+    AptStatus,
+    Op,
+    date,
+    dateStart,
+    dateEnd,
+    ClinicNum,
+    DateTStamp,
+    Offset,
+  }: GetAppointmentParams = {}): Promise<Appointment[]> {
+    const params = {
+      PatNum,
+      AptStatus,
+      Op,
+      date,
+      dateStart,
+      dateEnd,
+      ClinicNum,
+      DateTStamp,
+      Offset,
+    };
+  
+    return this.httpClient.get<Appointment[]>("/appointments", params);
+  }
+
+  /**
+   * Fetch ASAP appointments.
+   * @param {Object} params - Parameters for fetching ASAP appointments.
+   * @param {number} params.ClinicNum - Required: Clinic number. Use 0 for appointments not attached to clinics.
+   * @param {number} [params.ProvNum] - Optional: Provider number.
+   * @returns {Promise<Appointment[]>} - A list of ASAP appointments.
+   * @throws {Error} - If `ClinicNum` is not provided.
+   */
+  public async getASAPappointments(params: GetASAPParams): Promise<Appointment[]> {
+    if (!params.ClinicNum) {
+      throw new Error("ClinicNum is required when Clinics are enabled.");
     }
+    return this.httpClient.get<Appointment[]>("/appointments/asap", params);
+  }
 
-    public async getAppointments(params?: object): Promise<Appointment[]> {
-        return this.httpClient.get<Appointment[]>("/appointments", params);
+  /**
+   * Fetch available appointment slots.
+   * @param {Object} params - Parameters for filtering slots.
+   * @param {string} [params.date] - Search for a specific day in "yyyy-MM-dd" format.
+   * @param {string} [params.dateStart] - Start date for date range in "yyyy-MM-dd" format.
+   * @param {string} [params.dateEnd] - End date for date range in "yyyy-MM-dd" format.
+   * @param {number} [params.lengthMinutes] - Ignore slots shorter than this length.
+   * @param {number} [params.ProvNum] - Provider number.
+   * @param {number} [params.OpNum] - Operatory number.
+   * @returns {Promise<AppointmentSlot[]>} - A list of available slots.
+   */
+  public async getSlots(params?: GetSlotsParams): Promise<AppointmentSlot[]> {
+    return this.httpClient.get<AppointmentSlot[]>("/appointments/slots", params);
+  }
+
+  /**
+   * Fetch WebSched appointment slots.
+   * @param {Object} params - Parameters for filtering WebSched slots.
+   * @param {string} [params.date] - Search for a specific day in "yyyy-MM-dd" format.
+   * @param {string} [params.dateStart] - Start date for date range in "yyyy-MM-dd" format.
+   * @param {string} [params.dateEnd] - End date for date range in "yyyy-MM-dd" format.
+   * @param {number} params.ClinicNum - Required: Clinic number.
+   * @param {number} [params.defNumApptType] - Appointment type definition number.
+   * @param {"true" | "false"} [params.isNewPatient] - Indicates if the slot is for a new patient.
+   * @returns {Promise<AppointmentSlot[]>} - A list of WebSched slots.
+   * @throws {Error} - If `ClinicNum` is not provided.
+   */
+  public async getSlotsWebSched(params: GetSlotsWebSchedParams): Promise<AppointmentSlot[]> {
+    if (!params.ClinicNum) {
+      throw new Error("ClinicNum is required when Clinics are enabled.");
     }
+    return this.httpClient.get<AppointmentSlot[]>("/appointments/slotswebsched", params);
+  }
 
-    public async createAppointment(data: Partial<Appointment>): Promise<Appointment> {
-        if (!data) {
-        throw new Error("Appointment data is required.");
+  /**
+   * Fetch WebSched appointments.
+   * @param {Object} params - Parameters for fetching WebSched appointments.
+   * @param {string} [params.date] - Search for a specific day in "yyyy-MM-dd" format.
+   * @param {string} [params.dateStart] - Start date for date range in "yyyy-MM-dd" format.
+   * @param {string} [params.dateEnd] - End date for date range in "yyyy-MM-dd" format.
+   * @param {string} [params.DateTStamp] - Return only appointments updated after this timestamp.
+   * @param {number} [params.ClinicNum] - Clinic number.
+   * @returns {Promise<Appointment[]>} - A list of WebSched appointments.
+   */
+  public async getWebSchedAppointments(
+    params?: GetWebSchedAppointmentsParams
+  ): Promise<Appointment[]> {
+    return this.httpClient.get<Appointment[]>("/appointments/websched", params);
+  }
+
+  /**
+   * Create a new appointment.
+   * @param {Object} data - Data for the new appointment.
+   * @param {number} data.PatNum - Required: Patient number.
+   * @param {number} data.Op - Required: Operatory number.
+   * @param {string} data.AptDateTime - Required: Appointment start time in "yyyy-MM-dd HH:mm:ss" format.
+   * @param {"Scheduled" | "Complete" | "UnschedList" | "PtNote" | "PtNoteCompleted"} [data.AptStatus="Scheduled"] - Optional: Appointment status. Default is "Scheduled".
+   * @param {string} [data.Pattern="/XX/"] - Optional: Time pattern in 5-minute increments. Default is "/XX/" (20 minutes).
+   * @param {number} [data.Confirmed] - Optional: Confirmation status definition number.
+   * @param {string} [data.Note] - Optional: Appointment notes.
+   * @param {number} [data.ProvNum] - Optional: Provider number.
+   * @param {number} [data.ProvHyg=0] - Optional: Hygienist provider number. Default is 0.
+   * @param {number} [data.ClinicNum] - Optional: Clinic number.
+   * @param {"true" | "false"} [data.IsHygiene="false"] - Optional: Indicates if the appointment is for hygiene. Default is "false".
+   * @param {"true" | "false"} [data.IsNewPatient="false"] - Optional: Indicates if the patient is new. Default is "false".
+   * @param {"Normal" | "ASAP"} [data.Priority="Normal"] - Optional: Appointment priority. Default is "Normal".
+   * @param {number} [data.AppointmentTypeNum=0] - Optional: Appointment type number. Default is 0.
+   * @param {string} [data.colorOverride] - Optional: Custom color in "R,G,B" format.
+   * @param {string} [data.PatternSecondary] - Optional: Secondary time pattern.
+   * @returns {Promise<Appointment>} - The created appointment.
+   * @throws {Error} - If required fields are missing.
+   */
+    public async createNewAppointment(data: CreateNewAppointmentParams): Promise<Appointment> {
+        if (!data.PatNum || !data.Op || !data.AptDateTime) {
+          throw new Error("PatNum, Op, and AptDateTime are required.");
         }
+    
         return this.httpClient.post<Appointment>("/appointments", data);
+      }
+    
+
+  /**
+   * Create a planned appointment.
+   * @param {Object} data - Data for the planned appointment.
+   * @param {number} data.PatNum - Required: Patient number.
+   * @param {number} [data.AppointmentTypeNum] - Optional: Appointment type number.
+   * @param {number[]} [data.procNums] - Optional: Array of procedure numbers. At least one of `AppointmentTypeNum` or `procNums` is required.
+   * @param {string} [data.Pattern="/XX/"] - Optional: Time pattern in 5-minute increments. Default is "/XX/" (20 minutes).
+   * @param {number} [data.Confirmed] - Optional: Confirmation status definition number.
+   * @param {string} [data.Note] - Optional: Appointment notes.
+   * @param {number} [data.ProvNum] - Optional: Provider number.
+   * @param {number} [data.ProvHyg=0] - Optional: Hygienist provider number. Default is 0.
+   * @param {number} [data.ClinicNum] - Optional: Clinic number.
+   * @param {"true" | "false"} [data.IsHygiene="false"] - Optional: Indicates if the appointment is for hygiene. Default is "false".
+   * @param {"true" | "false"} [data.IsNewPatient="false"] - Optional: Indicates if the patient is new. Default is "false".
+   * @param {"Normal" | "ASAP"} [data.Priority="Normal"] - Optional: Appointment priority. Default is "Normal".
+   * @param {string} [data.PatternSecondary] - Optional: Secondary time pattern.
+   * @returns {Promise<Appointment>} - The created planned appointment.
+   * @throws {Error} - If required fields are missing.
+   */
+  public async createPlannedAppointment(data: CreatePlannedAppointmentParams): Promise<Appointment> {
+    if (!data.PatNum || (!data.AppointmentTypeNum && (!data.procNums || data.procNums.length === 0))) {
+      throw new Error("PatNum and either AppointmentTypeNum or procNums are required.");
+    }
+
+    return this.httpClient.post<Appointment>("/appointments/planned", data);
+  }
+
+
+  /**
+   * Schedule a planned appointment.
+   * @param {Object} data - Data for scheduling the planned appointment.
+   * @param {number} data.AptNum - Required: The appointment number with Planned status.
+   * @param {string} data.AptDateTime - Required: Start time for the appointment in "yyyy-MM-dd HH:mm:ss" format.
+   * @param {number} data.ProvNum - Required: The provider number for the appointment.
+   * @param {number} data.Op - Required: The operatory number for the appointment.
+   * @param {number} [data.Confirmed] - Optional: Confirmation status definition number.
+   * @param {string} [data.Note] - Optional: Notes for the appointment. Will overwrite any existing note.
+   * @returns {Promise<Appointment>} - The scheduled appointment.
+   * @throws {Error} - If required fields are missing.
+   */
+  public async schedulePlannedAppointment(
+    data: SchedulePlannedAppointmentParams
+  ): Promise<Appointment> {
+    if (!data.AptNum || !data.AptDateTime || !data.ProvNum || !data.Op) {
+      throw new Error("AptNum, AptDateTime, ProvNum, and Op are required.");
+    }
+
+    return this.httpClient.post<Appointment>("/appointments/scheduleplanned", data);
+  }
+
+  /**
+   * Schedule a WebSched appointment.
+   * @param {Object} data - Data for scheduling the WebSched appointment.
+   * @param {number} data.PatNum - Required: Patient number.
+   * @param {string} data.DateTimeStart - Required: The start time of the appointment in "yyyy-MM-dd HH:mm:ss" format.
+   * @param {string} data.DateTimeEnd - Required: The end time of the appointment in "yyyy-MM-dd HH:mm:ss" format.
+   * @param {number} data.ProvNum - Required: Provider number associated with the appointment slot.
+   * @param {number} data.OpNum - Required: Operatory number associated with the appointment slot.
+   * @param {number} data.defNumApptType - Required: Appointment type definition number.
+   * @returns {Promise<Appointment>} - The scheduled WebSched appointment.
+   * @throws {Error} - If required fields are missing.
+   */
+  public async scheduleWebSchedAppointment(
+    data: ScheduleWebSchedAppointmentParams
+  ): Promise<Appointment> {
+    if (
+      !data.PatNum ||
+      !data.DateTimeStart ||
+      !data.DateTimeEnd ||
+      !data.ProvNum ||
+      !data.OpNum ||
+      !data.defNumApptType
+    ) {
+      throw new Error(
+        "PatNum, DateTimeStart, DateTimeEnd, ProvNum, OpNum, and defNumApptType are required."
+      );
+    }
+
+    return this.httpClient.post<Appointment>("/appointments/websched", data);
+  }
+
+  /**
+   * Update an existing appointment.
+   * @param {Object} data - Data for updating the appointment.
+   * @param {number} data.AptNum - Required: The unique identifier of the appointment to update.
+   * @param {"Scheduled" | "Complete" | "UnschedList" | "Broken" | "Planned" | "PtNote" | "PtNoteCompleted"} [data.AptStatus] - Optional: Updated status of the appointment.
+   * @param {string} [data.Pattern] - Optional: Updated time pattern in 5-minute increments.
+   * @param {number} [data.Confirmed] - Optional: Updated confirmation status definition number.
+   * @param {number} [data.Op] - Optional: Updated operatory number.
+   * @param {string} [data.Note] - Optional: Updated notes for the appointment. Will overwrite existing notes.
+   * @param {number} [data.ProvNum] - Optional: Updated provider number.
+   * @param {number} [data.ProvHyg] - Optional: Updated hygienist provider number.
+   * @param {string} [data.AptDateTime] - Optional: Updated appointment start time in "yyyy-MM-dd HH:mm:ss" format.
+   * @param {number} [data.ClinicNum] - Optional: Updated clinic number.
+   * @param {"true" | "false"} [data.IsHygiene] - Optional: Indicates if the appointment is for hygiene.
+   * @param {"true" | "false"} [data.IsNewPatient] - Optional: Indicates if the appointment is for a new patient.
+   * @param {"Normal" | "ASAP"} [data.Priority] - Optional: Updated priority of the appointment.
+   * @param {number} [data.AppointmentTypeNum] - Optional: Updated appointment type number.
+   * @param {number} [data.UnschedStatus] - Optional: Updated unscheduled status definition number.
+   * @param {string} [data.colorOverride] - Optional: Updated custom color in "R,G,B" format.
+   * @param {string} [data.PatternSecondary] - Optional: Updated secondary time pattern.
+   * @returns {Promise<Appointment>} - The updated appointment.
+   * @throws {Error} - If `AptNum` is missing.
+   */
+  public async updateAppointment(data: UpdateAppointmentParams): Promise<Appointment> {
+    if (!data.AptNum) {
+      throw new Error("AptNum is required.");
+    }
+
+    return this.httpClient.put<Appointment>(`/appointments/${data.AptNum}`, data);
+  }
+
+  /**
+   * Break an existing appointment.
+   * Only appointments with an AptStatus of "Scheduled" can be broken.
+   * @param {Object} data - Data for breaking the appointment.
+   * @param {number} data.AptNum - Required: The unique identifier of the appointment to break.
+   * @param {"true" | "false"} data.sendToUnscheduledList - Required: Indicates if the appointment should be added to the Unscheduled List.
+   * @param {"Missed" | "Cancelled"} [data.breakType] - Optional: Reason for breaking the appointment.
+   * @returns {Promise<void>} - Resolves when the appointment is successfully broken.
+   * @throws {Error} - If required fields are missing.
+   */
+  public async breakAppointment(data: BreakAppointmentParams): Promise<void> {
+    if (!data.AptNum || !data.sendToUnscheduledList) {
+      throw new Error("AptNum and sendToUnscheduledList are required.");
     }
+
+    return this.httpClient.put<void>(`/appointments/${data.AptNum}/break`, data);
+  }
+
+  /**
+   * Update the note for an existing appointment.
+   * @param {number} AptNum - Required: The unique identifier of the appointment to update.
+   * @param {string} Note - Required: The new note content for the appointment.
+   * @returns {Promise<void>} - Resolves when the note is successfully updated.
+   * @throws {Error} - If required fields are missing.
+   */
+  public async updateAppointmentNote(AptNum: number, Note: string): Promise<void> {
+    if (!AptNum || !Note) {
+      throw new Error("AptNum and Note are required.");
+    }
+
+    return this.httpClient.put<void>(`/appointments/${AptNum}/note`, { Note });
+  }
+  
+  /**
+   * Confirm an existing appointment.
+   * @param {Object} data - Data for confirming the appointment.
+   * @param {number} data.AptNum - Required: The unique identifier of the appointment to confirm.
+   * @param {string} [data.confirmVal] - Optional: Confirmation value, e.g., "Sent", "Confirmed".
+   * @param {number} [data.defNum] - Optional: Confirmation definition number.
+   * @returns {Promise<void>} - Resolves when the appointment is successfully confirmed.
+   * @throws {Error} - If required fields are missing.
+   */
+  public async confirmAppointment(data: ConfirmAppointmentParams): Promise<void> {
+    if (!data.AptNum || (!data.confirmVal && !data.defNum)) {
+      throw new Error("AptNum and either confirmVal or defNum are required.");
+    }
+
+    return this.httpClient.put<void>(`/appointments/${data.AptNum}/confirm`, data);
+  }
+
 }

package/src/api/commlogs.ts

@@ -0,0 +1,63 @@
+import HttpClient from "../utils/httpClient";
+import { CommLog, CreateCommLogParams } from "../types/commlogType";
+
+export default class CommLogs {
+  private httpClient: HttpClient;
+
+  constructor(httpClient: HttpClient) {
+    this.httpClient = httpClient;
+  }
+
+  /**
+   * Fetch communication logs for a specific patient.
+   * @param {number} PatNum - Required: The unique identifier for the patient.
+   * @returns {Promise<CommLog[]>} - A list of communication logs for the patient.
+   * @throws {Error} - If `PatNum` is not provided or the API returns an error.
+   */
+  public async getCommLogs(PatNum: number): Promise<CommLog[]> {
+    if (!PatNum || typeof PatNum !== "number") {
+      throw new Error("Invalid parameter: PatNum must be a valid number.");
+    }
+
+    return this.httpClient.get<CommLog[]>("/commlogs", { PatNum });
+  }
+
+  /**
+   * Create a new communication log.
+   * @param {CreateCommLogParams} params - The details of the communication log to create.
+   * @param {number} params.PatNum - Required: The unique identifier for the patient.
+   * @param {string} params.CommDateTime - Required: Date and time of the communication in "yyyy-MM-dd HH:mm:ss" format.
+   * @param {"None" | "Email" | "Mail" | "Phone" | "In Person" | "Text" | "Email and Text" | "Phone and Text"} params.Mode_ - Required: Mode of communication.
+   * @param {string} params.Note - Required: Detailed note about the communication.
+   * @param {number} [params.CommType] - Optional: Type of communication: definition.DefNum where definition.Category=25.
+   * @param {string} [params.commType] - Optional: Human-readable description of the communication type.
+   * @param {"Sent" | "Received" | "Neither"} [params.SentOrReceived] - Optional: Direction of communication.
+   * @returns {Promise<CommLog>} - The created communication log.
+   * @throws {Error} - If required fields are missing or the API returns an error.
+   */
+  public async createCommLog({
+    PatNum,
+    CommDateTime,
+    Mode_,
+    Note,
+    CommType,
+    commType,
+    SentOrReceived,
+  }: CreateCommLogParams): Promise<CommLog> {
+    if (!PatNum || !CommDateTime || !Mode_ || !Note) {
+      throw new Error(
+        "Invalid data: PatNum, CommDateTime, Mode_, and Note are required."
+      );
+    }
+
+    return this.httpClient.post<CommLog>("/commlogs", {
+      PatNum,
+      CommDateTime,
+      Mode_,
+      Note,
+      CommType,
+      commType,
+      SentOrReceived,
+    });
+  }
+}