@eka-care/ekascribe-ts-sdk 1.4.39

package/dist/index.js

@@ -0,0 +1,267 @@
+// ekascribe main Class having all the methods - Entry point
+import { getConfigV2 } from './api/get-voice-api-v2-config';
+import { getVoiceApiV3Status } from './api/get-voice-api-v3-status';
+import patchTransactionStatus from './api/patch-transaction-status';
+import postTransactionCommit from './api/post-transaction-commit';
+import AudioBufferManager from './audio-chunker/audio-buffer-manager';
+import AudioFileManager from './audio-chunker/audio-file-manager';
+import VadWebClient from './audio-chunker/vad-web';
+import { AUDIO_BUFFER_SIZE_IN_S, DESP_CHUNK_LENGTH, FRAME_RATE, MAX_CHUNK_LENGTH, PREF_CHUNK_LENGTH, SAMPLING_RATE, SDK_STATUS_CODE, } from './constants/constant';
+import { ERROR_CODE } from './constants/enums';
+import setEnv from './fetch-client/helper';
+import endVoiceRecording from './main/end-recording';
+import pauseVoiceRecording from './main/pause-recording';
+import resumeVoiceRecording from './main/resume-recording';
+import retryUploadFailedFiles from './main/retry-upload-recording';
+import startVoiceRecording from './main/start-recording';
+import EkaScribeStore from './store/store';
+import initialiseTransaction from './main/init-transaction';
+import getTransactionHistory from './api/get-transaction-history';
+class EkaScribe {
+    // Private constructor to prevent direct instantiation
+    constructor() {
+        Object.defineProperty(this, "vadInstance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // vadWebClient Instance
+        Object.defineProperty(this, "audioFileManagerInstance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // AudioFileManager Instance
+        Object.defineProperty(this, "audioBufferInstance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.audioFileManagerInstance = new AudioFileManager();
+        console.log('%c Line:48 🥕 this.audioFileManagerInstance', 'color:#b03734', this.audioFileManagerInstance);
+        EkaScribeStore.audioFileManagerInstance = this.audioFileManagerInstance;
+        this.audioBufferInstance = new AudioBufferManager(SAMPLING_RATE, AUDIO_BUFFER_SIZE_IN_S);
+        console.log('%c Line:50 🍇 this.audioBufferInstance', 'color:#fca650', this.audioBufferInstance);
+        EkaScribeStore.audioBufferInstance = this.audioBufferInstance;
+        this.vadInstance = new VadWebClient(PREF_CHUNK_LENGTH, DESP_CHUNK_LENGTH, MAX_CHUNK_LENGTH, FRAME_RATE);
+        EkaScribeStore.vadInstance = this.vadInstance;
+        console.log('%c Line:62 🍖 this.vadInstance', 'color:#2eafb0', this.vadInstance);
+    }
+    // Static method to get the singleton instance with optional initialization
+    static getInstance({ access_token, env, clientId, }) {
+        if (!EkaScribe.instance) {
+            EkaScribe.instance = new EkaScribe();
+            // Initialize if params are provided
+            if (access_token) {
+                setEnv({
+                    auth_token: access_token,
+                    env,
+                    clientId,
+                });
+            }
+        }
+        return EkaScribe.instance;
+    }
+    // Method to reset the singleton instance (useful for testing)
+    static resetInstance() {
+        EkaScribe.instance = null;
+    }
+    async getEkascribeConfig() {
+        console.log('Fetching EkaScribe configuration...');
+        const response = await getConfigV2();
+        return response;
+    }
+    updateAuthTokens({ access_token }) {
+        setEnv({
+            auth_token: access_token,
+        });
+    }
+    async initTransaction(request) {
+        console.log('Initializing transaction...');
+        const initTransactionResponse = await initialiseTransaction(request);
+        console.log(initTransactionResponse, 'initTransactionResponse');
+        return initTransactionResponse;
+    }
+    async startRecording() {
+        console.log('Starting recording...');
+        const startResponse = await startVoiceRecording();
+        console.log('%c Line:110 🍓 startResponse', 'color:#465975', startResponse);
+        return startResponse;
+    }
+    reinitializeVad() {
+        this.vadInstance.reinitializeVad();
+    }
+    pauseRecording() {
+        console.log('Pausing recording...');
+        const pauseRecordingResponse = pauseVoiceRecording();
+        console.log('%c Line:117 🍌 pauseRecordingResponse', 'color:#6ec1c2', pauseRecordingResponse);
+        return pauseRecordingResponse;
+    }
+    resumeRecording() {
+        console.log('Resuming recording...');
+        const resumeRecordingResponse = resumeVoiceRecording();
+        console.log('%c Line:124 🌶 resumeRecordingResponse', 'color:#33a5ff', resumeRecordingResponse);
+        return resumeRecordingResponse;
+    }
+    async endRecording() {
+        console.log('Ending recording...');
+        const endRecordingResponse = await endVoiceRecording();
+        console.log('%c Line:131 🍅 endRecordingResponse', 'color:#e41a6a', endRecordingResponse);
+        return endRecordingResponse;
+    }
+    async retryUploadRecording({ force_commit }) {
+        console.log('Retrying upload for failed files...');
+        const retryUploadResponse = await retryUploadFailedFiles({ force_commit });
+        console.log('%c Line:138 🍖 retryUploadResponse', 'color:#3f7cff', retryUploadResponse);
+        return retryUploadResponse;
+    }
+    async patchSessionStatus({ sessionId, processing_status, processing_error, }) {
+        try {
+            const patchTransactionResponse = await patchTransactionStatus({
+                sessionId,
+                processing_status,
+                processing_error,
+            });
+            this.resetEkaScribe();
+            return patchTransactionResponse;
+        }
+        catch (error) {
+            console.error('Error cancelling recording session:', error);
+            return {
+                code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+                message: `Failed to cancel recording session, ${error}`,
+            };
+        }
+    }
+    async commitTransactionCall() {
+        try {
+            const txnID = EkaScribeStore.txnID;
+            let txnCommitMsg = '';
+            if (EkaScribeStore.sessionStatus[txnID].api?.status === 'stop' ||
+                EkaScribeStore.sessionStatus[txnID].api?.status === 'commit') {
+                const audioInfo = this.audioFileManagerInstance?.audioChunks;
+                const audioFiles = audioInfo.map((audio) => audio.fileName);
+                const { message, code: txnCommitStatusCode } = await postTransactionCommit({
+                    audioFiles,
+                    txnId: EkaScribeStore.txnID,
+                });
+                txnCommitMsg = message;
+                if (txnCommitStatusCode != 200) {
+                    return {
+                        error_code: ERROR_CODE.TXN_COMMIT_FAILED,
+                        status_code: txnCommitStatusCode,
+                        message: txnCommitMsg || 'Transaction commit failed.',
+                    };
+                }
+                EkaScribeStore.sessionStatus[txnID] = {
+                    ...EkaScribeStore.sessionStatus[txnID],
+                    api: {
+                        status: 'commit',
+                        code: txnCommitStatusCode,
+                        response: txnCommitMsg,
+                    },
+                };
+            }
+            else {
+                // transaction is not stopped or committed
+                return {
+                    error_code: ERROR_CODE.TXN_STATUS_MISMATCH,
+                    status_code: SDK_STATUS_CODE.TXN_ERROR,
+                    message: 'Transaction is not initialised or stopped. Cannot end recording.',
+                };
+            }
+            return {
+                status_code: SDK_STATUS_CODE.SUCCESS,
+                message: txnCommitMsg || 'Transaction committed successfully.',
+            };
+        }
+        catch (error) {
+            console.error('Error in transaction commit: ', error);
+            return {
+                error_code: ERROR_CODE.INTERNAL_SERVER_ERROR,
+                status_code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+                message: `Failed to cancel recording session, ${error}`,
+            };
+        }
+    }
+    async stopTransactionCall() {
+        // call endRecording method since all the steps are same
+        const endRecordingResponse = await endVoiceRecording();
+        return endRecordingResponse;
+    }
+    async getTemplateOutput({ txn_id }) {
+        try {
+            const getStatusResponse = await getVoiceApiV3Status({
+                txnId: txn_id,
+            });
+            return getStatusResponse;
+        }
+        catch (error) {
+            console.error('Error in fetching templates response: ', error);
+            return {
+                status_code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+                message: `Failed to fetch output templates, ${error}`,
+            };
+        }
+    }
+    async getSessionHistory({ txn_count }) {
+        try {
+            const transactionsResponse = await getTransactionHistory({
+                txn_count,
+            });
+            return transactionsResponse;
+        }
+        catch (error) {
+            console.error('Error cancelling recording session:', error);
+            return {
+                status_code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+                message: `Failed to fetch previous transactions, ${error}`,
+            };
+        }
+    }
+    getSuccessFiles() {
+        return this.audioFileManagerInstance.getSuccessfulUploads();
+    }
+    getFailedFiles() {
+        return this.audioFileManagerInstance.getFailedUploads();
+    }
+    getTotalAudioFiles() {
+        return this.audioFileManagerInstance.getTotalAudioChunks();
+    }
+    resetEkaScribe() {
+        this.audioFileManagerInstance.resetFileManagerInstance();
+        this.audioBufferInstance.resetBufferManagerInstance();
+        this.vadInstance.resetVadWebInstance();
+        EkaScribeStore.resetStore();
+    }
+    onError(callback) {
+        EkaScribeStore.errorCallback = callback;
+    }
+    onUserSpeechCallback(callback) {
+        EkaScribeStore.userSpeechCallback = callback;
+    }
+    onFileUploadProgressCallback(callback) {
+        this.audioFileManagerInstance.setProgressCallback(callback);
+    }
+    configureVadConstants({ pref_length, desp_length, max_length, sr, frame_size, pre_speech_pad_frames, short_thsld, long_thsld, }) {
+        return this.vadInstance.configureVadConstants({
+            pref_length,
+            desp_length,
+            max_length,
+            sr,
+            frame_size,
+            pre_speech_pad_frames,
+            short_thsld,
+            long_thsld,
+        });
+    }
+}
+Object.defineProperty(EkaScribe, "instance", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: null
+});
+// Export the singleton instance getter with optional initialization
+export const getEkaScribeInstance = ({ access_token, env, clientId, }) => EkaScribe.getInstance({ access_token, env, clientId });

package/dist/main/end-recording.d.ts

@@ -0,0 +1,3 @@
+import { TEndRecordingResponse } from '../constants/types';
+declare const endVoiceRecording: () => Promise<TEndRecordingResponse>;
+export default endVoiceRecording;

package/dist/main/end-recording.js

@@ -0,0 +1,141 @@
+import postTransactionCommit from '../api/post-transaction-commit';
+import postTransactionStop from '../api/post-transaction-stop';
+import { OUTPUT_FORMAT, SDK_STATUS_CODE } from '../constants/constant';
+import { ERROR_CODE } from '../constants/enums';
+import EkaScribeStore from '../store/store';
+const endVoiceRecording = async () => {
+    try {
+        const audioBufferInstance = EkaScribeStore.audioBufferInstance;
+        const fileManagerInstance = EkaScribeStore.audioFileManagerInstance;
+        const vadInstance = EkaScribeStore.vadInstance;
+        const txnID = EkaScribeStore.txnID;
+        if (!fileManagerInstance || !audioBufferInstance || !vadInstance) {
+            throw new Error('Class instances are not initialized');
+        }
+        vadInstance.pauseVad();
+        EkaScribeStore.sessionStatus[txnID] = {
+            ...EkaScribeStore.sessionStatus[txnID],
+            vad: {
+                status: 'stop',
+            },
+        };
+        // upload last audio chunk
+        if (audioBufferInstance.getCurrentSampleLength() > 0) {
+            const audioFrames = audioBufferInstance.getAudioData();
+            const filenumber = (fileManagerInstance.audioChunks.length || 0) + 1;
+            const fileName = `${filenumber}.${OUTPUT_FORMAT}`;
+            const rawSampleDetails = fileManagerInstance.getRawSampleDetails();
+            const chunkTimestamps = audioBufferInstance.calculateChunkTimestamps(rawSampleDetails.totalRawSamples);
+            const chunkInfo = {
+                fileName,
+                timestamp: {
+                    st: chunkTimestamps.start,
+                    et: chunkTimestamps.end,
+                },
+                status: 'pending',
+                audioFrames,
+            };
+            const audioChunkLength = fileManagerInstance.updateAudioInfo(chunkInfo);
+            fileManagerInstance?.incrementInsertedSamples(audioBufferInstance.getCurrentSampleLength(), audioBufferInstance.getCurrentFrameLength());
+            audioBufferInstance.resetBufferState();
+            await fileManagerInstance.uploadAudioToS3({
+                audioFrames,
+                fileName,
+                chunkIndex: audioChunkLength - 1,
+            });
+        }
+        await fileManagerInstance.waitForAllUploads();
+        const audioInfo = fileManagerInstance?.audioChunks;
+        const audioFiles = audioInfo.map((audio) => audio.fileName);
+        // call stop txn api
+        if (EkaScribeStore.sessionStatus[txnID].api?.status === 'init') {
+            const { message: txnStopMsg, code: txnStopStatusCode } = await postTransactionStop({
+                audioFiles,
+                txnId: txnID,
+            });
+            if (txnStopStatusCode != 200) {
+                return {
+                    error_code: ERROR_CODE.TXN_STOP_FAILED,
+                    status_code: txnStopStatusCode,
+                    message: txnStopMsg || 'Transaction stop failed.',
+                };
+            }
+            EkaScribeStore.sessionStatus[txnID] = {
+                ...EkaScribeStore.sessionStatus[txnID],
+                api: {
+                    status: 'stop',
+                    code: txnStopStatusCode,
+                    response: txnStopMsg,
+                },
+            };
+        }
+        else if (EkaScribeStore.sessionStatus[txnID].api?.status === 'na') {
+            // transaction is not initialised
+            return {
+                error_code: ERROR_CODE.TXN_STATUS_MISMATCH,
+                status_code: SDK_STATUS_CODE.TXN_ERROR,
+                message: 'Transaction is not initialized. Cannot end recording.',
+            };
+        }
+        const failedFiles = fileManagerInstance.getFailedUploads() || [];
+        let retryFailedFiles = [];
+        // retry upload once if there are any failed uploads
+        if (failedFiles.length > 0) {
+            retryFailedFiles = await fileManagerInstance.retryFailedUploads();
+        }
+        // if there are still failed uploads after retry, return error
+        if (retryFailedFiles.length > 0) {
+            return {
+                error_code: ERROR_CODE.AUDIO_UPLOAD_FAILED,
+                status_code: SDK_STATUS_CODE.AUDIO_ERROR,
+                message: 'Audio upload failed for some files after retry.',
+                failed_files: retryFailedFiles,
+                total_audio_files: audioFiles,
+            };
+        }
+        // call commit transaction api
+        if (EkaScribeStore.sessionStatus[txnID].api?.status === 'stop' ||
+            EkaScribeStore.sessionStatus[txnID].api?.status === 'commit') {
+            const { message: txnCommitMsg, code: txnCommitStatusCode } = await postTransactionCommit({
+                txnId: txnID,
+                audioFiles,
+            });
+            if (txnCommitStatusCode != 200) {
+                return {
+                    error_code: ERROR_CODE.TXN_COMMIT_FAILED,
+                    status_code: txnCommitStatusCode,
+                    message: txnCommitMsg || 'Transaction stop failed.',
+                };
+            }
+            EkaScribeStore.sessionStatus[txnID] = {
+                ...EkaScribeStore.sessionStatus[txnID],
+                api: {
+                    status: 'commit',
+                    code: txnCommitStatusCode,
+                    response: txnCommitMsg,
+                },
+            };
+        }
+        else {
+            // transaction is not stopped or committed
+            return {
+                error_code: ERROR_CODE.TXN_STATUS_MISMATCH,
+                status_code: SDK_STATUS_CODE.TXN_ERROR,
+                message: 'Transaction is not initialised or stopped. Cannot end recording.',
+            };
+        }
+        return {
+            status_code: SDK_STATUS_CODE.SUCCESS,
+            message: 'Recording ended successfully.',
+        };
+    }
+    catch (error) {
+        console.error('Error ending recording: ', error);
+        return {
+            error_code: ERROR_CODE.INTERNAL_SERVER_ERROR,
+            status_code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+            message: `An error occurred while ending the recording: ${error}`,
+        };
+    }
+};
+export default endVoiceRecording;

package/dist/main/init-transaction.d.ts

@@ -0,0 +1,3 @@
+import { TStartRecordingRequest, TStartRecordingResponse } from '../constants/types';
+declare const initialiseTransaction: ({ mode, input_language, output_format_template, txn_id, auto_download, model_training_consent, transfer, system_info, patient_details, }: TStartRecordingRequest) => Promise<TStartRecordingResponse>;
+export default initialiseTransaction;

package/dist/main/init-transaction.js

@@ -0,0 +1,86 @@
+import postTransactionInit from '../api/post-transaction-init';
+import { S3_BUCKET_NAME, SDK_STATUS_CODE } from '../constants/constant';
+import { ERROR_CODE } from '../constants/enums';
+import EkaScribeStore from '../store/store';
+const initialiseTransaction = async ({ mode, input_language, output_format_template, txn_id, auto_download, model_training_consent, transfer, system_info, patient_details, }) => {
+    try {
+        const fileManagerInstance = EkaScribeStore.audioFileManagerInstance;
+        const sessionStatus = EkaScribeStore.sessionStatus;
+        let businessID = '';
+        let userOID = '';
+        let userUUID = '';
+        if (!sessionStatus[txn_id] ||
+            Object.keys(sessionStatus[txn_id]).length === 0 ||
+            sessionStatus[txn_id].api?.status === 'na') {
+            EkaScribeStore.txnID = txn_id;
+            // File path calculation
+            const date = new Date();
+            // Format date to YYYYMMDD
+            const day = date.getDate().toString().padStart(2, '0');
+            const month = (date.getMonth() + 1).toString().padStart(2, '0');
+            const year = date.getFullYear().toString().substring(2);
+            // s3 file path format: <date>/txnID
+            const filePath = `${year}${month}${day}/${txn_id}`;
+            EkaScribeStore.sessionBucketPath = filePath;
+            const txnInitResponse = await postTransactionInit({
+                mode,
+                txnId: txn_id,
+                s3Url: `s3://${S3_BUCKET_NAME}/${filePath}`,
+                input_language,
+                output_format_template,
+                transfer,
+                auto_download,
+                model_training_consent,
+                system_info,
+                patient_details,
+            });
+            const { code: txnInitStatusCode, b_id: businessId, oid, uuid, message: txnInitMessage, error: txnInitError, } = txnInitResponse;
+            if (txnInitStatusCode === 400 && txnInitError?.code === ERROR_CODE.TXN_LIMIT_EXCEEDED) {
+                return {
+                    error_code: ERROR_CODE.TXN_LIMIT_EXCEEDED,
+                    status_code: txnInitStatusCode,
+                    message: txnInitMessage || 'Transaction limit exceeded.',
+                };
+            }
+            if (txnInitStatusCode >= 400) {
+                return {
+                    error_code: ERROR_CODE.TXN_INIT_FAILED,
+                    status_code: txnInitStatusCode,
+                    message: txnInitMessage || 'Transaction initialization failed.',
+                };
+            }
+            EkaScribeStore.sessionStatus[txn_id] = {
+                api: {
+                    status: 'init',
+                    code: txnInitStatusCode,
+                    response: txnInitMessage,
+                },
+            };
+            businessID = businessId;
+            userOID = oid;
+            userUUID = uuid;
+            fileManagerInstance?.setSessionInfo({
+                sessionId: txn_id,
+                filePath: filePath,
+                businessID: businessId,
+            });
+        }
+        return {
+            message: 'Transaction initialized successfully.',
+            status_code: SDK_STATUS_CODE.SUCCESS,
+            business_id: businessID,
+            oid: userOID,
+            uuid: userUUID,
+            txn_id,
+        };
+    }
+    catch (err) {
+        console.log('%c Line:102 🍇 initialiseTransaction err', 'color:#b03734', err);
+        return {
+            error_code: ERROR_CODE.INTERNAL_SERVER_ERROR,
+            status_code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+            message: `An error occurred in initializing the transaction: ${err}`,
+        };
+    }
+};
+export default initialiseTransaction;

package/dist/main/pause-recording.d.ts

@@ -0,0 +1,3 @@
+import { TPauseRecordingResponse } from '../constants/types';
+declare const pauseVoiceRecording: () => TPauseRecordingResponse;
+export default pauseVoiceRecording;

package/dist/main/pause-recording.js

@@ -0,0 +1,59 @@
+import { OUTPUT_FORMAT, SDK_STATUS_CODE } from '../constants/constant';
+import { ERROR_CODE } from '../constants/enums';
+import EkaScribeStore from '../store/store';
+const pauseVoiceRecording = () => {
+    try {
+        const audioBufferInstance = EkaScribeStore.audioBufferInstance;
+        const fileManagerInstance = EkaScribeStore.audioFileManagerInstance;
+        const vadInstance = EkaScribeStore.vadInstance;
+        if (!fileManagerInstance || !audioBufferInstance || !vadInstance) {
+            throw new Error('Class instances are not initialized');
+        }
+        vadInstance.pauseVad();
+        const txn_id = EkaScribeStore.txnID;
+        EkaScribeStore.sessionStatus[txn_id] = {
+            ...EkaScribeStore.sessionStatus[txn_id],
+            vad: {
+                status: 'pause',
+            },
+        };
+        if (audioBufferInstance.getCurrentSampleLength() > 0) {
+            const audioFrames = audioBufferInstance.getAudioData();
+            const filenumber = (fileManagerInstance.audioChunks.length || 0) + 1;
+            const fileName = `${filenumber}.${OUTPUT_FORMAT}`;
+            const rawSampleDetails = fileManagerInstance.getRawSampleDetails();
+            const chunkTimestamps = audioBufferInstance.calculateChunkTimestamps(rawSampleDetails.totalRawSamples);
+            const chunkInfo = {
+                fileName,
+                timestamp: {
+                    st: chunkTimestamps.start,
+                    et: chunkTimestamps.end,
+                },
+                status: 'pending',
+                audioFrames,
+            };
+            const audioChunkLength = fileManagerInstance.updateAudioInfo(chunkInfo);
+            fileManagerInstance?.incrementInsertedSamples(audioBufferInstance.getCurrentSampleLength(), audioBufferInstance.getCurrentFrameLength());
+            audioBufferInstance.resetBufferState();
+            fileManagerInstance.uploadAudioToS3({
+                audioFrames,
+                fileName,
+                chunkIndex: audioChunkLength - 1,
+            });
+        }
+        return {
+            status_code: SDK_STATUS_CODE.SUCCESS,
+            message: 'Recording paused successfully',
+            is_paused: true,
+        };
+    }
+    catch (error) {
+        console.log('%c Line:7 🍔 pauseRecording error', 'color:#3f7cff', error);
+        return {
+            error_code: ERROR_CODE.INTERNAL_SERVER_ERROR,
+            status_code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+            message: `An error occurred while starting the recording: ${error}`,
+        };
+    }
+};
+export default pauseVoiceRecording;

package/dist/main/resume-recording.d.ts

@@ -0,0 +1,3 @@
+import { TPauseRecordingResponse } from '../constants/types';
+declare const resumeVoiceRecording: () => TPauseRecordingResponse;
+export default resumeVoiceRecording;

package/dist/main/resume-recording.js

@@ -0,0 +1,33 @@
+import { SDK_STATUS_CODE } from '../constants/constant';
+import { ERROR_CODE } from '../constants/enums';
+import EkaScribeStore from '../store/store';
+const resumeVoiceRecording = () => {
+    try {
+        const vadInstance = EkaScribeStore.vadInstance;
+        if (!vadInstance) {
+            throw new Error('VAD instance is not initialized');
+        }
+        vadInstance.startVad();
+        const txn_id = EkaScribeStore.txnID;
+        EkaScribeStore.sessionStatus[txn_id] = {
+            ...EkaScribeStore.sessionStatus[txn_id],
+            vad: {
+                status: 'resume',
+            },
+        };
+        return {
+            status_code: SDK_STATUS_CODE.SUCCESS,
+            message: 'Recording resumed successfully',
+            is_paused: false,
+        };
+    }
+    catch (error) {
+        console.error('Error resuming recording:', error);
+        return {
+            error_code: ERROR_CODE.INTERNAL_SERVER_ERROR,
+            status_code: SDK_STATUS_CODE.INTERNAL_SERVER_ERROR,
+            message: `Failed to resume recording: ${error}`,
+        };
+    }
+};
+export default resumeVoiceRecording;

package/dist/main/retry-upload-recording.d.ts

@@ -0,0 +1,5 @@
+import { TEndRecordingResponse } from '../constants/types';
+declare const retryUploadFailedFiles: ({ force_commit, }: {
+    force_commit: boolean;
+}) => Promise<TEndRecordingResponse>;
+export default retryUploadFailedFiles;