@eka-care/ekascribe-ts-sdk 1.5.87 → 1.5.88

package/dist/main/start-recording.js

@@ -1,54 +1,62 @@
-import { SDK_STATUS_CODE } from '../constants/constant';
-import { ERROR_CODE } from '../constants/enums';
-import EkaScribeStore from '../store/store';
-const startVoiceRecording = async () => {
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constant_1 = require("../constants/constant");
+const enums_1 = require("../constants/enums");
+const store_1 = require("../store/store");
+const startVoiceRecording = () => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const vadInstance = EkaScribeStore.vadInstance;
-        const navigatorPermissionResponse = await navigator.permissions.query({
+        const vadInstance = store_1.default.vadInstance;
+        const navigatorPermissionResponse = yield navigator.permissions.query({
             name: 'microphone',
         });
         if (navigatorPermissionResponse.state !== 'granted') {
             return {
-                error_code: ERROR_CODE.MICROPHONE,
-                status_code: SDK_STATUS_CODE.FORBIDDEN,
+                error_code: enums_1.ERROR_CODE.MICROPHONE,
+                status_code: constant_1.SDK_STATUS_CODE.FORBIDDEN,
                 message: 'Microphone access is required to start recording. Please recheck access.',
             };
         }
-        await vadInstance?.initVad();
-        const micVad = vadInstance?.getMicVad();
-        const isVadLoading = vadInstance?.isVadLoading();
+        yield (vadInstance === null || vadInstance === void 0 ? void 0 : vadInstance.initVad());
+        const micVad = vadInstance === null || vadInstance === void 0 ? void 0 : vadInstance.getMicVad();
+        const isVadLoading = vadInstance === null || vadInstance === void 0 ? void 0 : vadInstance.isVadLoading();
         if (isVadLoading || !micVad || Object.keys(micVad).length === 0) {
             // retry initiating vad once and if still is in loading return error
-            const reinitializeVadResponse = await vadInstance?.reinitializeVad();
+            const reinitializeVadResponse = yield (vadInstance === null || vadInstance === void 0 ? void 0 : vadInstance.reinitializeVad());
             if (reinitializeVadResponse) {
                 return {
-                    error_code: ERROR_CODE.VAD_NOT_INITIALIZED,
-                    status_code: SDK_STATUS_CODE.FORBIDDEN,
+                    error_code: enums_1.ERROR_CODE.VAD_NOT_INITIALIZED,
+                    status_code: constant_1.SDK_STATUS_CODE.FORBIDDEN,
                     message: 'VAD instance is not initialized. Please try again later.',
                 };
             }
         }
-        vadInstance?.startVad();
-        const txn_id = EkaScribeStore.txnID;
-        EkaScribeStore.sessionStatus[txn_id] = {
-            ...EkaScribeStore.sessionStatus[txn_id],
-            vad: {
+        vadInstance === null || vadInstance === void 0 ? void 0 : vadInstance.startVad();
+        const txn_id = store_1.default.txnID;
+        store_1.default.sessionStatus[txn_id] = Object.assign(Object.assign({}, store_1.default.sessionStatus[txn_id]), { vad: {
                 status: 'start',
-            },
-        };
+            } });
         return {
             message: 'Recording started successfully.',
-            status_code: SDK_STATUS_CODE.SUCCESS,
+            status_code: constant_1.SDK_STATUS_CODE.SUCCESS,
             txn_id,
         };
     }
     catch (err) {
         console.log('%c Line:102 🍇 startRecording err', 'color:#b03734', err);
         return {
-            error_code: ERROR_CODE.INTERNAL_SERVER_ERROR,
-            status_code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+            error_code: enums_1.ERROR_CODE.INTERNAL_SERVER_ERROR,
+            status_code: constant_1.SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
             message: `An error occurred while starting the recording: ${err}`,
         };
     }
-};
-export default startVoiceRecording;
+});
+exports.default = startVoiceRecording;

package/dist/main/upload-full-audio-with-presigned-url.js

@@ -1,76 +1,91 @@
-import postV1FileUpload from '../api/post-v1-file-upload';
-import postTransactionInit from '../api/transaction/post-transaction-init';
-import uploadFilesWithPresignedUrl from '../api/upload-audio-with-presigned-url';
-import { SDK_STATUS_CODE } from '../constants/constant';
-import { ERROR_CODE } from '../constants/enums';
-export async function postV1UploadAudioFiles({ audioFiles, audioFileNames, txn_id, action, transfer, mode, input_language, output_language, output_format_template, model_training_consent, auto_download, system_info, patient_details, model_type, version, flavour, }) {
-    try {
-        // Step 1: Get presigned URL
-        const presignedUrlResponse = await postV1FileUpload({ txn_id, action });
-        if (presignedUrlResponse.code !== 200) {
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postV1UploadAudioFiles = postV1UploadAudioFiles;
+const post_v1_file_upload_1 = require("../api/post-v1-file-upload");
+const post_transaction_init_1 = require("../api/transaction/post-transaction-init");
+const upload_audio_with_presigned_url_1 = require("../api/upload-audio-with-presigned-url");
+const constant_1 = require("../constants/constant");
+const enums_1 = require("../constants/enums");
+function postV1UploadAudioFiles(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ audioFiles, audioFileNames, txn_id, action, transfer, mode, input_language, output_language, output_format_template, model_training_consent, auto_download, system_info, patient_details, model_type, version, flavour, }) {
+        var _b;
+        try {
+            // Step 1: Get presigned URL
+            const presignedUrlResponse = yield (0, post_v1_file_upload_1.default)({ txn_id, action });
+            if (presignedUrlResponse.code !== 200) {
+                return {
+                    error_code: enums_1.ERROR_CODE.GET_PRESIGNED_URL_FAILED,
+                    status_code: presignedUrlResponse.code || constant_1.SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+                    message: presignedUrlResponse.message || 'Get presigned URL failed',
+                };
+            }
+            // Step 2: Upload files using the presigned URL
+            const uploadResponse = yield (0, upload_audio_with_presigned_url_1.default)({
+                audioFiles,
+                audioFileNames,
+                presignedUrlResponse,
+            });
+            if (uploadResponse.code !== 200) {
+                return {
+                    error_code: enums_1.ERROR_CODE.AUDIO_UPLOAD_FAILED,
+                    status_code: uploadResponse.code || constant_1.SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+                    message: uploadResponse.message || 'File uploaded.',
+                };
+            }
+            const batch_s3_url = presignedUrlResponse.uploadData.url + presignedUrlResponse.folderPath;
+            const initTransactionResponse = yield (0, post_transaction_init_1.default)({
+                mode,
+                txn_id,
+                input_language,
+                output_language,
+                output_format_template,
+                model_training_consent,
+                auto_download,
+                transfer,
+                system_info,
+                patient_details,
+                model_type,
+                version,
+                flavour,
+                batch_s3_url,
+                audio_file_names: audioFileNames,
+            });
+            if (initTransactionResponse.code === 400 &&
+                ((_b = initTransactionResponse.error) === null || _b === void 0 ? void 0 : _b.code) === enums_1.ERROR_CODE.TXN_LIMIT_EXCEEDED) {
+                return {
+                    error_code: enums_1.ERROR_CODE.TXN_LIMIT_EXCEEDED,
+                    status_code: initTransactionResponse.code,
+                    message: initTransactionResponse.message || 'Transaction limit exceeded.',
+                };
+            }
+            if (initTransactionResponse.code >= 400) {
+                return {
+                    error_code: enums_1.ERROR_CODE.TXN_INIT_FAILED,
+                    status_code: initTransactionResponse.code || constant_1.SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+                    message: initTransactionResponse.message || 'Transaction initialization failed.',
+                };
+            }
             return {
-                error_code: ERROR_CODE.GET_PRESIGNED_URL_FAILED,
-                status_code: presignedUrlResponse.code || SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
-                message: presignedUrlResponse.message || 'Get presigned URL failed',
+                status_code: constant_1.SDK_STATUS_CODE.SUCCESS,
+                message: 'Recording uploaded successfully.',
             };
         }
-        // Step 2: Upload files using the presigned URL
-        const uploadResponse = await uploadFilesWithPresignedUrl({
-            audioFiles,
-            audioFileNames,
-            presignedUrlResponse,
-        });
-        if (uploadResponse.code !== 200) {
+        catch (error) {
+            console.error('getPresignedUrlAndUploadFiles error:', error);
             return {
-                error_code: ERROR_CODE.AUDIO_UPLOAD_FAILED,
-                status_code: uploadResponse.code || SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
-                message: uploadResponse.message || 'File uploaded.',
+                error_code: enums_1.ERROR_CODE.INTERNAL_SERVER_ERROR,
+                status_code: constant_1.SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+                message: `Recording upload failed: ${error}`,
             };
         }
-        const batch_s3_url = presignedUrlResponse.uploadData.url + presignedUrlResponse.folderPath;
-        const initTransactionResponse = await postTransactionInit({
-            mode,
-            txn_id,
-            input_language,
-            output_language,
-            output_format_template,
-            model_training_consent,
-            auto_download,
-            transfer,
-            system_info,
-            patient_details,
-            model_type,
-            version,
-            flavour,
-            batch_s3_url,
-            audio_file_names: audioFileNames,
-        });
-        if (initTransactionResponse.code === 400 &&
-            initTransactionResponse.error?.code === ERROR_CODE.TXN_LIMIT_EXCEEDED) {
-            return {
-                error_code: ERROR_CODE.TXN_LIMIT_EXCEEDED,
-                status_code: initTransactionResponse.code,
-                message: initTransactionResponse.message || 'Transaction limit exceeded.',
-            };
-        }
-        if (initTransactionResponse.code >= 400) {
-            return {
-                error_code: ERROR_CODE.TXN_INIT_FAILED,
-                status_code: initTransactionResponse.code || SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
-                message: initTransactionResponse.message || 'Transaction initialization failed.',
-            };
-        }
-        return {
-            status_code: SDK_STATUS_CODE.SUCCESS,
-            message: 'Recording uploaded successfully.',
-        };
-    }
-    catch (error) {
-        console.error('getPresignedUrlAndUploadFiles error:', error);
-        return {
-            error_code: ERROR_CODE.INTERNAL_SERVER_ERROR,
-            status_code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
-            message: `Recording upload failed: ${error}`,
-        };
-    }
+    });
 }

package/dist/shared-worker/s3-file-upload.js

@@ -1,12 +1,23 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 // window is undefined in sharedWorker so it is needed to decode the XML AWS error
 if (typeof window === 'undefined') {
     self.window = self;
 }
-import { configureAWS } from '../aws-services/configure-aws';
-import pushFileToS3 from '../aws-services/upload-file-to-s3';
-import { AUDIO_EXTENSION_TYPE_MAP, OUTPUT_FORMAT } from '../constants/constant';
-import { SHARED_WORKER_ACTION } from '../constants/enums';
-import compressAudioToMp3 from '../utils/compress-mp3-audio';
+const configure_aws_1 = require("../aws-services/configure-aws");
+const upload_file_to_s3_1 = require("../aws-services/upload-file-to-s3");
+const constant_1 = require("../constants/constant");
+const enums_1 = require("../constants/enums");
+const compress_mp3_audio_1 = require("../utils/compress-mp3-audio");
 // onconnect - to establish communication channel with the main thread
 // eslint-disable-next-line
 // @ts-ignore
@@ -16,75 +27,81 @@ onconnect = function (event) {
     let uploadRequestReceived = 0;
     let uploadRequestCompleted = 0;
     // onmessage - to handle messages from the main thread
-    workerPort.onmessage = async function (event) {
-        const workerData = event.data;
-        switch (workerData.action) {
-            case SHARED_WORKER_ACTION.CONFIGURE_AWS: {
-                try {
-                    const { accessKeyId, secretKey, sessionToken } = workerData.payload;
-                    configureAWS({
-                        accessKeyId,
-                        secretKey,
-                        sessionToken,
-                    });
-                    workerPort.postMessage({
-                        action: SHARED_WORKER_ACTION.CONFIGURE_AWS_SUCCESS,
-                        message: 'AWS configured successfully',
-                    });
-                }
-                catch (error) {
-                    workerPort.postMessage({
-                        action: SHARED_WORKER_ACTION.CONFIGURE_AWS_ERROR,
-                        error: error || 'Failed to configure AWS',
-                    });
-                }
-                return;
-            }
-            case SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER: {
-                const { fileName, audioFrames, txnID, businessID, fileBlob, s3BucketName } = workerData.payload;
-                uploadRequestReceived++;
-                let audioBlob;
-                let compressedAudioBuffer;
-                if (fileBlob) {
-                    audioBlob = fileBlob;
+    workerPort.onmessage = function (event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workerData = event.data;
+            switch (workerData.action) {
+                case enums_1.SHARED_WORKER_ACTION.CONFIGURE_AWS: {
+                    try {
+                        const { accessKeyId, secretKey, sessionToken } = workerData.payload;
+                        (0, configure_aws_1.configureAWS)({
+                            accessKeyId,
+                            secretKey,
+                            sessionToken,
+                        });
+                        workerPort.postMessage({
+                            action: enums_1.SHARED_WORKER_ACTION.CONFIGURE_AWS_SUCCESS,
+                            message: 'AWS configured successfully',
+                        });
+                    }
+                    catch (error) {
+                        workerPort.postMessage({
+                            action: enums_1.SHARED_WORKER_ACTION.CONFIGURE_AWS_ERROR,
+                            error: error || 'Failed to configure AWS',
+                        });
+                    }
+                    return;
                 }
-                else {
-                    compressedAudioBuffer = compressAudioToMp3(audioFrames);
-                    audioBlob = new Blob(compressedAudioBuffer, {
-                        type: AUDIO_EXTENSION_TYPE_MAP[OUTPUT_FORMAT],
+                case enums_1.SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER: {
+                    const { fileName, audioFrames, txnID, businessID, fileBlob, s3BucketName } = workerData.payload;
+                    uploadRequestReceived++;
+                    let audioBlob;
+                    let compressedAudioBuffer;
+                    if (fileBlob) {
+                        audioBlob = fileBlob;
+                    }
+                    else {
+                        compressedAudioBuffer = (0, compress_mp3_audio_1.default)(audioFrames);
+                        audioBlob = new Blob(compressedAudioBuffer, {
+                            type: constant_1.AUDIO_EXTENSION_TYPE_MAP[constant_1.OUTPUT_FORMAT],
+                        });
+                    }
+                    yield (0, upload_file_to_s3_1.default)({
+                        s3BucketName,
+                        fileBlob: audioBlob,
+                        fileName,
+                        txnID,
+                        businessID,
+                        is_shared_worker: true,
+                    })
+                        .then((response) => {
+                        uploadRequestCompleted++;
+                        // postMessage - to send messages back to the main thread
+                        workerPort.postMessage({
+                            action: enums_1.SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER_SUCCESS,
+                            response,
+                            requestBody: Object.assign(Object.assign({}, workerData.payload), { fileBlob: audioBlob, compressedAudioBuffer }),
+                        });
+                    })
+                        .catch((error) => {
+                        console.log(error, 'shared worker - file upload');
+                        uploadRequestCompleted++;
                     });
+                    return;
                 }
-                await pushFileToS3({
-                    s3BucketName,
-                    fileBlob: audioBlob,
-                    fileName,
-                    txnID,
-                    businessID,
-                    is_shared_worker: true,
-                })
-                    .then((response) => {
-                    uploadRequestCompleted++;
-                    // postMessage - to send messages back to the main thread
-                    workerPort.postMessage({
-                        action: SHARED_WORKER_ACTION.UPLOAD_FILE_WITH_WORKER_SUCCESS,
-                        response,
-                        requestBody: {
-                            ...workerData.payload,
-                            fileBlob: audioBlob,
-                            compressedAudioBuffer,
-                        },
-                    });
-                })
-                    .catch((error) => {
-                    console.log(error, 'shared worker - file upload');
-                    uploadRequestCompleted++;
-                });
-                return;
-            }
-            case SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS: {
-                if (uploadRequestReceived === uploadRequestCompleted) {
+                case enums_1.SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS: {
+                    if (uploadRequestReceived === uploadRequestCompleted) {
+                        workerPort.postMessage({
+                            action: enums_1.SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS_SUCCESS,
+                            response: {
+                                uploadRequestReceived,
+                                uploadRequestCompleted,
+                            },
+                        });
+                        return;
+                    }
                     workerPort.postMessage({
-                        action: SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS_SUCCESS,
+                        action: enums_1.SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS_ERROR,
                         response: {
                             uploadRequestReceived,
                             uploadRequestCompleted,
@@ -92,16 +109,8 @@ onconnect = function (event) {
                     });
                     return;
                 }
-                workerPort.postMessage({
-                    action: SHARED_WORKER_ACTION.WAIT_FOR_ALL_UPLOADS_ERROR,
-                    response: {
-                        uploadRequestReceived,
-                        uploadRequestCompleted,
-                    },
-                });
-                return;
             }
-        }
+        });
     };
     workerPort.postMessage(`[WORKER] Web worker onmessage established ${JSON.stringify(workerPort)}`);
     // start the worker port to listen for messages

package/dist/store/store.js

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 class EkaScribeStore {
     constructor() {
         Object.defineProperty(this, "_txnID", {
@@ -149,4 +151,4 @@ class EkaScribeStore {
         this._vadFrameProcessedCallback = null;
     }
 }
-export default EkaScribeStore.getInstance();
+exports.default = EkaScribeStore.getInstance();

package/dist/utils/compress-mp3-audio.js

@@ -1,8 +1,10 @@
-import * as lamejs from '@breezystack/lamejs';
-import { BITRATE, SAMPLING_RATE } from '../constants/constant';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lamejs = require("@breezystack/lamejs");
+const constant_1 = require("../constants/constant");
 const compressAudioToMp3 = (audio) => {
     try {
-        const audioEncoder = new lamejs.Mp3Encoder(1, SAMPLING_RATE, BITRATE);
+        const audioEncoder = new lamejs.Mp3Encoder(1, constant_1.SAMPLING_RATE, constant_1.BITRATE);
         // convert Float32Array to Int16Array
         const samples = new Int16Array(audio.length);
         for (let i = 0; i < audio.length; i++) {
@@ -21,4 +23,4 @@ const compressAudioToMp3 = (audio) => {
         return [];
     }
 };
-export default compressAudioToMp3;
+exports.default = compressAudioToMp3;

package/dist/utils/get-worker-url.js

@@ -1,19 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSharedWorkerUrl = getSharedWorkerUrl;
 /**
  * Get the URL for the shared worker file
  * This function handles both bundled and unbundled scenarios
  */
-export function getSharedWorkerUrl() {
+function getSharedWorkerUrl() {
     // Allow consumers to override the worker URL via global config
     if (typeof window !== 'undefined' && window.__EKA_SDK_WORKER_URL__) {
         return window.__EKA_SDK_WORKER_URL__;
     }
-    // Try to use import.meta.url if available (ESM, unbundled)
-    if (typeof import.meta !== 'undefined' && import.meta.url) {
+    // Try to use document.currentScript for browser environments (CommonJS/UMD)
+    if (typeof document !== 'undefined' && document.currentScript) {
         try {
-            const baseUrl = import.meta.url;
-            // If baseUrl is a string, use it to construct the worker URL
-            if (typeof baseUrl === 'string') {
-                return new URL('../shared-worker/s3-file-upload.js', baseUrl).href;
+            const script = document.currentScript;
+            if (script.src) {
+                const baseUrl = script.src.substring(0, script.src.lastIndexOf('/'));
+                // Construct path to shared worker relative to current script
+                const workerPath = baseUrl + '/shared-worker/s3-file-upload.js';
+                return workerPath;
             }
         }
         catch (e) {

package/dist/utils/search-past-sessions.js

@@ -1,3 +1,15 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchSessionsBySessionId = exports.searchSessionsByPatient = void 0;
 // Generic debounce utility function
 function debounce(func, delay) {
     let timeoutId;
@@ -17,7 +29,8 @@ const searchByPatientName = (sessions, patientName) => {
     }
     const searchTerm = patientName.toLowerCase().trim();
     return sessions.filter((session) => {
-        if (!session.patient_details?.username)
+        var _a;
+        if (!((_a = session.patient_details) === null || _a === void 0 ? void 0 : _a.username))
             return false;
         return session.patient_details.username.toLowerCase().includes(searchTerm);
     });
@@ -51,20 +64,21 @@ const performSearch = (sessions, searchCriteria) => {
 // Debounced search function
 const debouncedSearch = debounce(performSearch, 300);
 // Main search function
-const searchSessions = async ({ sessions, searchCriteria, }) => {
+const searchSessions = (_a) => __awaiter(void 0, [_a], void 0, function* ({ sessions, searchCriteria, }) {
     return debouncedSearch(sessions, searchCriteria);
-};
-const searchSessionsByPatient = async ({ sessions, patientName, }) => {
+});
+const searchSessionsByPatient = (_a) => __awaiter(void 0, [_a], void 0, function* ({ sessions, patientName, }) {
     return searchSessions({
         sessions,
         searchCriteria: { patientName },
     });
-};
-const searchSessionsBySessionId = async ({ sessions, sessionId, }) => {
+});
+exports.searchSessionsByPatient = searchSessionsByPatient;
+const searchSessionsBySessionId = (_a) => __awaiter(void 0, [_a], void 0, function* ({ sessions, sessionId, }) {
     return searchSessions({
         sessions,
         searchCriteria: { sessionId },
     });
-};
-export default searchSessions;
-export { searchSessionsByPatient, searchSessionsBySessionId };
+});
+exports.searchSessionsBySessionId = searchSessionsBySessionId;
+exports.default = searchSessions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eka-care/ekascribe-ts-sdk",
-  "version": "1.5.87",
+  "version": "1.5.88",
   "main": "dist/index.js",
   "repository": "git@github.com:eka-care/eka-js-sdk.git",
   "author": "Sanikagoyal28 <sanikagoyal9@gmail.com>",