@rinse-dental/open-dental 0.0.6

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,34 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+          scope: '@rinse-dental'
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/README.md

@@ -0,0 +1 @@
+#Hello World

package/__tests__/example.test.ts

@@ -0,0 +1,6 @@
+describe('Example Test', () => {
+    it('should pass', () => {
+      expect(1 + 1).toBe(2);
+    });
+  });
+  

package/dist/api/appointments.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Appointments {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    /**
+     * 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.
+    */
+    async getAppointment(AptNum) {
+        if (!AptNum) {
+            throw new Error("AptNum is required.");
+        }
+        return this.httpClient.get(`/appointments/${AptNum}`);
+    }
+    async getAppointments(params) {
+        return this.httpClient.get("/appointments", params);
+    }
+    async createAppointment(data) {
+        if (!data) {
+            throw new Error("Appointment data is required.");
+        }
+        return this.httpClient.post("/appointments", data);
+    }
+}
+exports.default = Appointments;

package/dist/api/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Appointments = exports.Patients = void 0;
+var patients_1 = require("./patients");
+Object.defineProperty(exports, "Patients", { enumerable: true, get: function () { return __importDefault(patients_1).default; } });
+var appointments_1 = require("./appointments");
+Object.defineProperty(exports, "Appointments", { enumerable: true, get: function () { return __importDefault(appointments_1).default; } });
+//export { default as ProcedureLogs } from "./procedureLogs";
+// Add other APIs as needed

package/dist/api/patients.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Patients {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async getPatient(params) {
+        if (!params.PatNum) {
+            throw new Error("PatNum is required.");
+        }
+        return this.httpClient.get(`/patients/${params.PatNum}`);
+    }
+    async getPatients() {
+        return this.httpClient.get("/patients");
+    }
+}
+exports.default = Patients;

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenDental = void 0;
+var openDental_1 = require("./openDental");
+Object.defineProperty(exports, "OpenDental", { enumerable: true, get: function () { return openDental_1.OpenDental; } });

package/dist/openDental.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenDental = void 0;
+const httpClient_1 = __importDefault(require("./utils/httpClient"));
+const patients_1 = __importDefault(require("./api/patients"));
+const appointments_1 = __importDefault(require("./api/appointments"));
+class OpenDental {
+    static httpClient;
+    /**
+     * Initialize the OpenDental library with the base URL and auth token.
+     */
+    static initialize(baseURL, authToken) {
+        if (!baseURL || !authToken) {
+            throw new Error("Both baseURL and authToken are required.");
+        }
+        //to manage future versions of the API
+        baseURL = baseURL + "/api/v1";
+        this.httpClient = new httpClient_1.default(baseURL, authToken);
+    }
+    /**
+     * Create a new instance of the Patients API.
+     */
+    static Patients() {
+        if (!this.httpClient) {
+            throw new Error("OpenDental not initialized. Call OpenDental.initialize() first.");
+        }
+        return new patients_1.default(this.httpClient);
+    }
+    /**
+     * Create a new instance of the Appointments API.
+     */
+    static Appointments() {
+        if (!this.httpClient) {
+            throw new Error("OpenDental not initialized. Call OpenDental.initialize() first.");
+        }
+        return new appointments_1.default(this.httpClient);
+    }
+}
+exports.OpenDental = OpenDental;

package/dist/utils/errorHandler.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils/httpClient.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+class HttpClient {
+    client;
+    constructor(baseURL, authToken) {
+        this.client = axios_1.default.create({
+            baseURL,
+            headers: {
+                Authorization: authToken,
+                "Content-Type": "application/json",
+            },
+        });
+    }
+    /**
+     * GET request
+     * @param {string} url - The endpoint URL
+     * @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);
+        }
+    }
+    /**
+     * POST request
+     * @param {string} url - The endpoint URL
+     * @param {object} data - The payload to send
+     * @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);
+        }
+    }
+    /**
+     * PUT request
+     * @param {string} url - The endpoint URL
+     * @param {object} data - The payload to update
+     * @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);
+        }
+    }
+    /**
+     * DELETE request
+     * @param {string} url - The endpoint URL
+     * @returns {Promise<T>} - The API response
+     */
+    async delete(url) {
+        try {
+            const response = await this.client.delete(url);
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Error handler to provide detailed error information
+     * @param {AxiosError} error - The error object from Axios
+     */
+    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
+                console.error("API Response Error:", {
+                    status: error.response.status,
+                    data: error.response.data,
+                    headers: error.response.headers,
+                });
+                throw new Error(`Request failed with status ${error.response.status}: ${JSON.stringify(error.response.data)}`);
+            }
+            else if (error.request) {
+                // The request was made, but no response was 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
+                console.error("Request Setup Error:", error.message);
+                throw new Error(`Request setup failed: ${error.message}`);
+            }
+        }
+        else {
+            // Handle non-Axios errors
+            console.error("Unexpected Error:", error);
+            throw new Error("An unexpected error occurred.");
+        }
+    }
+}
+exports.default = HttpClient;

package/dist/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "@rinse-dental/open-dental",
+    "version": "0.0.6",
+    "description": "A TypeScript library for easily accessing Open Dental APIs.",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "author": "Rinse Dental Inc.",
+    "license": "MIT",
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/",
+        "access": "public"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/getrinsed/open-dental.git"
+    },
+    "dependencies": {
+        "axios": "^1.7.7",
+        "moment-timezone": "^0.5.46"
+    },
+    "devDependencies": {
+        "@types/jest": "^29.5.14",
+        "@types/node": "^22.9.3",
+        "jest": "^29.7.0",
+        "prettier": "^3.3.3",
+        "typescript": "^5.7.2"
+    },
+    "scripts": {
+        "build": "tsc",
+        "prepare": "npm run build",
+        "test": "jest"
+    }
+}

package/src/api/appointments.ts

@@ -0,0 +1,40 @@
+import HttpClient from "../utils/httpClient";
+import { Appointment } from "../utils/types";
+
+export interface IAppointments {
+    getAppointment(AptNum: number): Promise<Appointment>;
+    getAppointments(params?: object): Promise<Appointment[]>;
+    createAppointment(data: Partial<Appointment>): Promise<Appointment>;
+  }
+
+export default class Appointments implements IAppointments {
+    private httpClient: HttpClient;
+
+    constructor(httpClient: HttpClient) {
+        this.httpClient = httpClient;
+    }
+
+    /**
+     * 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}`);
+    }
+
+    public async getAppointments(params?: object): Promise<Appointment[]> {
+        return this.httpClient.get<Appointment[]>("/appointments", params);
+    }
+
+    public async createAppointment(data: Partial<Appointment>): Promise<Appointment> {
+        if (!data) {
+        throw new Error("Appointment data is required.");
+        }
+        return this.httpClient.post<Appointment>("/appointments", data);
+    }
+}

package/src/api/index.ts

@@ -0,0 +1,4 @@
+export { default as Patients } from "./patients";
+export { default as Appointments } from "./appointments";
+//export { default as ProcedureLogs } from "./procedureLogs";
+// Add other APIs as needed

package/src/api/patients.ts

@@ -0,0 +1,26 @@
+import HttpClient from "../utils/httpClient";
+import { Patient } from "../utils/types";
+
+export interface IPatients {
+  getPatient(params: { PatNum: number }): Promise<Patient>;
+  getPatients(): Promise<Patient[]>;
+}
+
+export default class Patients implements IPatients {
+  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.");
+    }
+    return this.httpClient.get<Patient>(`/patients/${params.PatNum}`);
+  }
+
+  public async getPatients(): Promise<Patient[]> {
+    return this.httpClient.get<Patient[]>("/patients");
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { OpenDental } from "./openDental";

package/src/openDental.ts

@@ -0,0 +1,43 @@
+import HttpClient from "./utils/httpClient";
+import Patients, { IPatients } from "./api/patients";
+import Appointments, { IAppointments } from "./api/appointments";
+
+class OpenDental {
+  private static httpClient: HttpClient;
+
+  /**
+   * Initialize the OpenDental library with the base URL and auth token.
+   */
+  public static initialize(baseURL: string, authToken: string): void {
+    if (!baseURL || !authToken) {
+      throw new Error("Both baseURL and authToken are required.");
+    }
+
+    //to manage future versions of the API
+    baseURL = baseURL + "/api/v1";
+
+    this.httpClient = new HttpClient(baseURL, authToken);
+  }
+
+  /**
+   * Create a new instance of the Patients API.
+   */
+  public static Patients(): IPatients {
+    if (!this.httpClient) {
+      throw new Error("OpenDental not initialized. Call OpenDental.initialize() first.");
+    }
+    return new Patients(this.httpClient);
+  }
+
+  /**
+   * Create a new instance of the Appointments API.
+   */
+  public static Appointments(): IAppointments {
+    if (!this.httpClient) {
+      throw new Error("OpenDental not initialized. Call OpenDental.initialize() first.");
+    }
+    return new Appointments(this.httpClient);
+  }
+}
+
+export { OpenDental };

package/src/utils/httpClient.ts

@@ -0,0 +1,109 @@
+import axios, { AxiosInstance, AxiosResponse, AxiosError } from "axios";
+
+class HttpClient {
+  private client: AxiosInstance;
+
+  constructor(baseURL: string, authToken: string) {
+    this.client = axios.create({
+      baseURL,
+      headers: {
+        Authorization: authToken,
+        "Content-Type": "application/json",
+      },
+    });
+  }
+
+  /**
+   * GET request
+   * @param {string} url - The endpoint URL
+   * @param {object} params - Optional query parameters
+   * @returns {Promise<T>} - The API response
+   */
+  public async get<T>(url: string, params?: object): Promise<T> {
+    try {
+      const response: AxiosResponse<T> = await this.client.get<T>(url, { params });
+      return response.data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  /**
+   * POST request
+   * @param {string} url - The endpoint URL
+   * @param {object} data - The payload to send
+   * @returns {Promise<T>} - The API response
+   */
+  public async post<T>(url: string, data: object): Promise<T> {
+    try {
+      const response: AxiosResponse<T> = await this.client.post<T>(url, data);
+      return response.data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  /**
+   * PUT request
+   * @param {string} url - The endpoint URL
+   * @param {object} data - The payload to update
+   * @returns {Promise<T>} - The API response
+   */
+  public async put<T>(url: string, data: object): Promise<T> {
+    try {
+      const response: AxiosResponse<T> = await this.client.put<T>(url, data);
+      return response.data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  /**
+   * DELETE request
+   * @param {string} url - The endpoint URL
+   * @returns {Promise<T>} - The API response
+   */
+  public async delete<T>(url: string): Promise<T> {
+    try {
+      const response: AxiosResponse<T> = await this.client.delete<T>(url);
+      return response.data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  /**
+   * Error handler to provide detailed error information
+   * @param {AxiosError} error - The error object from Axios
+   */
+  private handleError(error: unknown): never {
+    if (axios.isAxiosError(error)) {
+      // Handle Axios-specific error
+      if (error.response) {
+        // The request was made, and the server responded with a status code
+        console.error("API Response Error:", {
+          status: error.response.status,
+          data: error.response.data,
+          headers: error.response.headers,
+        });
+        throw new Error(
+          `Request failed with status ${error.response.status}: ${JSON.stringify(error.response.data)}`
+        );
+      } else if (error.request) {
+        // The request was made, but no response was 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
+        console.error("Request Setup Error:", error.message);
+        throw new Error(`Request setup failed: ${error.message}`);
+      }
+    } else {
+      // Handle non-Axios errors
+      console.error("Unexpected Error:", error);
+      throw new Error("An unexpected error occurred.");
+    }
+  }
+}  
+
+export default HttpClient;

package/src/utils/types.ts

@@ -0,0 +1,134 @@
+/**
+ * Represents a patient in the Open Dental system.
+ * @see https://www.opendental.com/site/apipatients.html
+ */
+export interface Patient {
+    PatNum: number; // Unique patient identifier
+    LName: string; // Last name
+    FName: string; // First name
+    MiddleI?: string; // Middle initial
+    Preferred?: string; // Preferred name
+    PatStatus: 'Patient' | 'NonPatient' | 'Inactive' | 'Archived' | 'Deceased' | 'Prospective'; // Patient status
+    Gender: 'Male' | 'Female' | 'Unknown' | 'Other'; // Gender
+    Position: 'Single' | 'Married' | 'Child' | 'Widowed' | 'Divorced'; // Marital status
+    Birthdate: string; // Date of birth in 'yyyy-MM-dd' format
+    SSN?: string; // Social Security Number
+    Address?: string; // Primary address
+    Address2?: string; // Secondary address
+    City?: string; // City
+    State?: string; // State
+    Zip?: string; // ZIP code
+    HmPhone?: string; // Home phone number
+    WkPhone?: string; // Work phone number
+    WirelessPhone?: string; // Mobile phone number
+    Guarantor: number; // Guarantor's PatNum
+    Email?: string; // Email address
+    EstBalance: number; // Estimated balance
+    PriProv: number; // Primary provider number
+    priProvAbbr?: string; // Primary provider abbreviation
+    SecProv?: number; // Secondary provider number
+    secProvAbbr?: string; // Secondary provider abbreviation
+    BillingType?: string; // Billing type description
+    ImageFolder?: string; // Image folder name
+    FamFinUrgNote?: string; // Family financial urgent note
+    ChartNumber?: string; // Chart number
+    MedicaidID?: string; // Medicaid ID
+    BalTotal: number; // Total balance
+    DateFirstVisit?: string; // Date of first visit in 'yyyy-MM-dd' format
+    ClinicNum?: number; // Clinic number
+    clinicAbbr?: string; // Clinic abbreviation
+    Ward?: string; // Ward
+    PreferConfirmMethod?: 'None' | 'Email' | 'TextMessage' | 'PhoneCall'; // Preferred confirmation method
+    PreferContactMethod?: 'None' | 'Email' | 'TextMessage' | 'PhoneCall' | 'Mail'; // Preferred contact method
+    PreferRecallMethod?: 'None' | 'Email' | 'TextMessage' | 'PhoneCall' | 'Mail'; // Preferred recall method
+    Language?: string; // Language code (ISO 639-2 format)
+    AdmitDate?: string; // Admission date in 'yyyy-MM-dd' format
+    siteDesc?: string; // Site description
+    DateTStamp: string; // Timestamp of the last update in 'yyyy-MM-dd HH:mm:ss' format
+    SuperFamily?: number; // Super family number
+    TxtMsgOk?: 'Unknown' | 'Yes' | 'No'; // Text message consent
+    SecDateEntry?: string; // Secondary date entry in 'yyyy-MM-dd' format
+  }
+  
+  /**
+   * Represents an appointment in the Open Dental system.
+   * @see https://www.opendental.com/site/apiappointments.html
+   */
+  export interface Appointment {
+    AptNum: number; // Unique appointment identifier
+    PatNum: number; // Patient's PatNum
+    AptStatus: 'Scheduled' | 'Complete' | 'UnschedList' | 'ASAP' | 'Broken' | 'Planned' | 'PtNote' | 'PtNoteCompleted'; // Appointment status
+    Pattern: string; // Time pattern
+    Confirmed: number; // Confirmation status code
+    confirmed?: string; // Confirmation status description
+    TimeLocked: boolean; // Indicates if the time is locked
+    Op: number; // Operatory number
+    Note?: string; // Appointment note
+    ProvNum: number; // Provider number
+    provAbbr?: string; // Provider abbreviation
+    ProvHyg?: number; // Hygienist provider number
+    AptDateTime: string; // Appointment date and time in 'yyyy-MM-dd HH:mm:ss' format
+    NextAptNum?: number; // Next appointment number
+    UnschedStatus?: number; // Unscheduled status code
+    unschedStatus?: string; // Unscheduled status description
+    IsNewPatient: boolean; // Indicates if the patient is new
+    ProcDescript?: string; // Procedure description
+    ClinicNum?: number; // Clinic number
+    IsHygiene: boolean; // Indicates if it's a hygiene appointment
+    DateTStamp: string; // Timestamp of the last update in 'yyyy-MM-dd HH:mm:ss' format
+    DateTimeArrived?: string; // Arrival time in 'yyyy-MM-dd HH:mm:ss' format
+    DateTimeSeated?: string; // Seated time in 'yyyy-MM-dd HH:mm:ss' format
+    DateTimeDismissed?: string; // Dismissed time in 'yyyy-MM-dd HH:mm:ss' format
+    InsPlan1?: number; // Primary insurance plan number
+    InsPlan2?: number; // Secondary insurance plan number
+    DateTimeAskedToArrive?: string; // Requested arrival time in 'yyyy-MM-dd HH:mm:ss' format
+    colorOverride?: string; // Color override in 'R,G,B' format
+    AppointmentTypeNum?: number; // Appointment type number
+    SecDateTEntry?: string; // Secondary date entry in 'yyyy-MM-dd' format
+    Priority?: 'Normal' | 'ASAP'; // Appointment priority
+    PatternSecondary?: string; // Secondary time pattern
+    ItemOrderPlanned?: number; // Planned item order
+  }
+  
+  /**
+ * Represents a procedure log entry in the Open Dental system.
+ * @see https://www.opendental.com/site/apiprocedurelogs.html
+ */
+export interface ProcedureLog {
+    ProcNum: number; // Unique procedure identifier
+    PatNum: number; // Patient's PatNum
+    AptNum?: number; // Associated appointment number
+    ProcDate: string; // Procedure date in 'yyyy-MM-dd' format
+    ProcFee: number; // Procedure fee
+    Surf?: string; // Tooth surface
+    ToothNum?: string; // Tooth number
+    ToothRange?: string; // Tooth range
+    Priority?: number; // Priority code
+    priority?: string; // Priority description
+    ProcStatus: 'TP' | 'C' | 'EO' | 'R' | 'D' | 'E'; // Procedure status: Treatment Planned (TP), Complete (C), Existing Other Provider (EO), Referred (R), Deleted (D), or Existing Current Provider (E)
+    ProvNum: number; // Provider number
+    provAbbr?: string; // Provider abbreviation
+    Dx?: string; // Diagnosis code
+    dxName?: string; // Diagnosis name
+    PlannedAptNum?: number; // Planned appointment number
+    DateEntryC?: string; // Date the procedure was created in 'yyyy-MM-dd HH:mm:ss' format
+    ClinicNum?: number; // Clinic number
+    MedicalCode?: string; // Medical procedure code
+    DiagnosticCode?: string; // Diagnostic code
+    CodeNum: number; // Procedure code number
+    codeText?: string; // Procedure code description
+    ProcNote?: string; // Procedure note
+    ToothColor?: string; // Tooth color (if applicable)
+    LabFee?: number; // Lab fee
+    IsProsth?: boolean; // Indicates if it's a prosthodontic procedure
+    ProcTime?: string; // Time taken for the procedure
+    PriorityNum?: number; // Priority number
+    Prosthesis?: 'None' | 'Crown' | 'Denture' | 'Bridge'; // Type of prosthesis
+    ProsthesisDate?: string; // Prosthesis delivery date in 'yyyy-MM-dd' format
+    UnitQty?: number; // Quantity of units
+    DateTStamp: string; // Timestamp of the last update in 'yyyy-MM-dd HH:mm:ss' format
+    SecDateTEntry?: string; // Secondary date entry in 'yyyy-MM-dd HH:mm:ss' format
+    MedicalOrderNum?: number; // Medical order number
+    PlaceService?: 'Office' | 'InpatientHospital' | 'OutpatientHospital'; // Place of service
+  }
+  

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "CommonJS",
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true
+    },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "dist"]
+}