@eka-care/ekascribe-ts-sdk 1.4.39

package/dist/constants/enums.d.ts

@@ -0,0 +1,46 @@
+export declare enum TEMPLATE_ID {
+    EKA_EMR_TEMPLATE = "eka_emr_template",
+    CLINICAL_NOTE_TEMPLATE = "clinical_notes_template",
+    TRANSCRIPT_TEMPLATE = "transcript_template",
+    EKA_EMR_TO_FHIR_TEMPLATE = "eka_emr_to_fhir_template",
+    NIC_TEMPLATE = "nic_template"
+}
+export declare enum RESULT_STATUS {
+    SUCCESS = "success",
+    FAILURE = "failure",
+    PARTIAL_COMPLETE = "partial_complete",
+    IN_PROGRESS = "in-progress"
+}
+export declare enum ERROR_CODE {
+    MICROPHONE = "microphone",
+    TXN_INIT_FAILED = "txn_init_failed",
+    TXN_LIMIT_EXCEEDED = "txn_limit_exceeded",
+    INTERNAL_SERVER_ERROR = "internal_server_error",
+    TXN_STOP_FAILED = "txn_stop_failed",
+    AUDIO_UPLOAD_FAILED = "audio_upload_failed",
+    TXN_COMMIT_FAILED = "txn_commit_failed",
+    INVALID_REQUEST = "invalid_request",
+    VAD_NOT_INITIALIZED = "vad_not_initialized",
+    NO_AUDIO_CAPTURE = "no_audio_capture",
+    SPEECH_DETECTED = "speech_detected",
+    TXN_STATUS_MISMATCH = "txn_status_mismatch",
+    LONG_SILENCE = "long_silence"
+}
+export declare enum PROCESSING_STATUS {
+    SUCCESS = "success",
+    IN_PROGRESS = "in-progress",
+    FAILED = "failed",
+    CANCELLED = "cancelled"
+}
+export declare enum SHARED_WORKER_ACTION {
+    UPLOAD_FILE_WITH_WORKER = "upload_file_with_worker",
+    UPLOAD_FILE_WITH_WORKER_SUCCESS = "upload_file_with_worker_success",
+    UPLOAD_FILE_WITH_WORKER_ERROR = "upload_file_with_worker_error",
+    TEST_WORKER = "test_worker",
+    CONFIGURE_AWS = "configure_aws",
+    CONFIGURE_AWS_SUCCESS = "configure_aws_success",
+    CONFIGURE_AWS_ERROR = "configure_aws_error",
+    WAIT_FOR_ALL_UPLOADS = "wait_for_all_uploads",
+    WAIT_FOR_ALL_UPLOADS_SUCCESS = "wait_for_all_uploads_success",
+    WAIT_FOR_ALL_UPLOADS_ERROR = "wait_for_all_uploads_error"
+}

package/dist/constants/enums.js

@@ -0,0 +1,51 @@
+export var TEMPLATE_ID;
+(function (TEMPLATE_ID) {
+    TEMPLATE_ID["EKA_EMR_TEMPLATE"] = "eka_emr_template";
+    TEMPLATE_ID["CLINICAL_NOTE_TEMPLATE"] = "clinical_notes_template";
+    TEMPLATE_ID["TRANSCRIPT_TEMPLATE"] = "transcript_template";
+    TEMPLATE_ID["EKA_EMR_TO_FHIR_TEMPLATE"] = "eka_emr_to_fhir_template";
+    TEMPLATE_ID["NIC_TEMPLATE"] = "nic_template";
+})(TEMPLATE_ID || (TEMPLATE_ID = {}));
+export var RESULT_STATUS;
+(function (RESULT_STATUS) {
+    RESULT_STATUS["SUCCESS"] = "success";
+    RESULT_STATUS["FAILURE"] = "failure";
+    RESULT_STATUS["PARTIAL_COMPLETE"] = "partial_complete";
+    RESULT_STATUS["IN_PROGRESS"] = "in-progress";
+})(RESULT_STATUS || (RESULT_STATUS = {}));
+export var ERROR_CODE;
+(function (ERROR_CODE) {
+    ERROR_CODE["MICROPHONE"] = "microphone";
+    ERROR_CODE["TXN_INIT_FAILED"] = "txn_init_failed";
+    ERROR_CODE["TXN_LIMIT_EXCEEDED"] = "txn_limit_exceeded";
+    ERROR_CODE["INTERNAL_SERVER_ERROR"] = "internal_server_error";
+    ERROR_CODE["TXN_STOP_FAILED"] = "txn_stop_failed";
+    ERROR_CODE["AUDIO_UPLOAD_FAILED"] = "audio_upload_failed";
+    ERROR_CODE["TXN_COMMIT_FAILED"] = "txn_commit_failed";
+    ERROR_CODE["INVALID_REQUEST"] = "invalid_request";
+    ERROR_CODE["VAD_NOT_INITIALIZED"] = "vad_not_initialized";
+    ERROR_CODE["NO_AUDIO_CAPTURE"] = "no_audio_capture";
+    ERROR_CODE["SPEECH_DETECTED"] = "speech_detected";
+    ERROR_CODE["TXN_STATUS_MISMATCH"] = "txn_status_mismatch";
+    ERROR_CODE["LONG_SILENCE"] = "long_silence";
+})(ERROR_CODE || (ERROR_CODE = {}));
+export var PROCESSING_STATUS;
+(function (PROCESSING_STATUS) {
+    PROCESSING_STATUS["SUCCESS"] = "success";
+    PROCESSING_STATUS["IN_PROGRESS"] = "in-progress";
+    PROCESSING_STATUS["FAILED"] = "failed";
+    PROCESSING_STATUS["CANCELLED"] = "cancelled";
+})(PROCESSING_STATUS || (PROCESSING_STATUS = {}));
+export var SHARED_WORKER_ACTION;
+(function (SHARED_WORKER_ACTION) {
+    SHARED_WORKER_ACTION["UPLOAD_FILE_WITH_WORKER"] = "upload_file_with_worker";
+    SHARED_WORKER_ACTION["UPLOAD_FILE_WITH_WORKER_SUCCESS"] = "upload_file_with_worker_success";
+    SHARED_WORKER_ACTION["UPLOAD_FILE_WITH_WORKER_ERROR"] = "upload_file_with_worker_error";
+    SHARED_WORKER_ACTION["TEST_WORKER"] = "test_worker";
+    SHARED_WORKER_ACTION["CONFIGURE_AWS"] = "configure_aws";
+    SHARED_WORKER_ACTION["CONFIGURE_AWS_SUCCESS"] = "configure_aws_success";
+    SHARED_WORKER_ACTION["CONFIGURE_AWS_ERROR"] = "configure_aws_error";
+    SHARED_WORKER_ACTION["WAIT_FOR_ALL_UPLOADS"] = "wait_for_all_uploads";
+    SHARED_WORKER_ACTION["WAIT_FOR_ALL_UPLOADS_SUCCESS"] = "wait_for_all_uploads_success";
+    SHARED_WORKER_ACTION["WAIT_FOR_ALL_UPLOADS_ERROR"] = "wait_for_all_uploads_error";
+})(SHARED_WORKER_ACTION || (SHARED_WORKER_ACTION = {}));

package/dist/constants/setup-config.d.ts

@@ -0,0 +1,14 @@
+import { TEMPLATE_ID } from './enums';
+export declare const SUPPORTED_LANGUAGES: {
+    id: string;
+    name: string;
+}[];
+export declare const SUPPORTED_OUTPUT_FORMATS: {
+    id: TEMPLATE_ID;
+    name: string;
+}[];
+export declare const CONSULTATION_MODES: {
+    id: string;
+    name: string;
+    desc: string;
+}[];

package/dist/constants/setup-config.js

@@ -0,0 +1,31 @@
+import { TEMPLATE_ID } from './enums';
+export const SUPPORTED_LANGUAGES = [
+    { id: 'en-IN', name: 'English (India)' },
+    { id: 'en-US', name: 'English (United States)' },
+    { id: 'hi', name: 'Hindi' },
+    { id: 'gu', name: 'Gujarati' },
+    { id: 'kn', name: 'Kannada' },
+    { id: 'ml', name: 'Malayalam' },
+    { id: 'ta', name: 'Tamil' },
+    { id: 'te', name: 'Telugu' },
+    { id: 'bn', name: 'Bengali' },
+    { id: 'mr', name: 'Marathi' },
+    { id: 'pa', name: 'Punjabi' },
+];
+export const SUPPORTED_OUTPUT_FORMATS = [
+    { id: TEMPLATE_ID.EKA_EMR_TEMPLATE, name: 'Eka EMR Format' },
+    { id: TEMPLATE_ID.CLINICAL_NOTE_TEMPLATE, name: 'Clinical Notes' },
+    { id: TEMPLATE_ID.TRANSCRIPT_TEMPLATE, name: 'Transcription' },
+];
+export const CONSULTATION_MODES = [
+    {
+        id: 'consultation',
+        name: 'Consultation',
+        desc: 'Eka Scribe will listen to your conversation and create clinical notes',
+    },
+    {
+        id: 'dictation',
+        name: 'Dictation',
+        desc: 'Dictate your notes to Eka Scribe and create clinical notes',
+    },
+];

package/dist/constants/types.d.ts

@@ -0,0 +1,224 @@
+import { ERROR_CODE } from './enums';
+export type TGetConfigV2Response = {
+    data?: {
+        supported_languages: TGetConfigItem[];
+        supported_output_formats: TGetConfigItem[];
+        consultation_modes: TGetConfigItem[];
+        max_selection: {
+            supported_languages: number;
+            supported_output_formats: number;
+            consultation_modes: number;
+        };
+        selected_preferences?: TSelectedPreferences;
+        settings?: TConfigSettings;
+        model?: string;
+    };
+    message?: string;
+    code?: number;
+};
+export type TSelectedPreferences = {
+    languages?: string[];
+    output_formats?: string[];
+    consultation_mode?: string;
+    use_audio_cues?: boolean;
+    auto_download?: boolean;
+};
+export type TGetConfigItem = {
+    id: string;
+    name: string;
+    desc?: string;
+};
+export type TConfigSettings = {
+    model_training_consent: {
+        value: boolean;
+        editable: boolean;
+    };
+};
+export type TStartRecordingRequest = {
+    mode: string;
+    input_language: string[];
+    output_format_template: {
+        template_id: string;
+    }[];
+    txn_id: string;
+    auto_download: boolean;
+    model_training_consent: boolean;
+    transfer: string;
+    system_info: TSystemInfo;
+    patient_details: TPatientDetails;
+};
+export type TPatientDetails = {
+    username: string;
+    oid: string;
+    age: number;
+    biologicalSex: string;
+    mobile?: string;
+    email?: string;
+};
+export type TSystemInfo = {
+    platform: string;
+    language: string;
+    hardware_concurrency?: number;
+    device_memory?: number;
+    time_zone: string;
+    network_info?: TNetworkInfo;
+};
+export type TNetworkInfo = {
+    effective_type: String;
+    latency: Number;
+    download_speed: Number;
+    connection_type: String;
+};
+export type TStartRecordingResponse = {
+    error_code?: ERROR_CODE;
+    status_code: number;
+    message: string;
+    business_id?: string;
+    txn_id?: string;
+    oid?: string;
+    uuid?: string;
+};
+export type TPauseRecordingResponse = {
+    status_code: number;
+    message: string;
+    error_code?: ERROR_CODE;
+    is_paused?: boolean;
+};
+export type TEndRecordingResponse = {
+    error_code?: ERROR_CODE;
+    status_code: number;
+    message: string;
+    failed_files?: string[];
+    total_audio_files?: string[];
+};
+export type TPostTransactionInitRequest = {
+    mode: string;
+    s3Url: string;
+    txnId: string;
+    input_language: string[];
+    output_format_template: {
+        template_id: string;
+    }[];
+    transfer: string;
+    auto_download: boolean;
+    model_training_consent: boolean;
+    system_info: TSystemInfo;
+    patient_details: TPatientDetails;
+};
+export type TPostTransactionCommitRequest = {
+    audioFiles: string[];
+    txnId: string;
+};
+export type TPostTransactionResponse = {
+    status: string;
+    message: string;
+    txn_id: string;
+    b_id: string;
+    oid: string;
+    uuid: string;
+    data: unknown;
+    code: number;
+    error?: {
+        code: string;
+        message: string;
+        display_message: string;
+    };
+};
+export type TPatchTransactionError = {
+    error: {
+        type: string;
+        code: string;
+        msg: string;
+    };
+};
+export type TPatchTransactionRequest = {
+    sessionId: string;
+    processing_status: string;
+    processing_error?: TPatchTransactionError;
+};
+export type TPostCogResponse = {
+    credentials?: {
+        AccessKeyId: string;
+        SecretKey: string;
+        SessionToken: string;
+        Expiration: string;
+    };
+    message?: string;
+    token?: string;
+    identity_id?: string;
+    is_session_expired?: boolean;
+};
+export type TEndV2RxResponse = {
+    error?: string;
+    success?: boolean;
+    is_upload_failed?: boolean;
+    stop_txn_error?: string;
+    commit_txn_error?: string;
+};
+export type TGetTransactionHistoryResponse = {
+    data?: TSessionHistoryData[];
+    status?: string;
+    status_code: number;
+    message: string;
+    retrieved_count?: number;
+};
+export type TSessionHistoryData = {
+    created_at: string;
+    b_id: string;
+    user_status: string;
+    processing_status: string;
+    txn_id: string;
+    mode: string;
+    uuid: string;
+    oid: string;
+};
+export type TAudioChunksInfo = {
+    fileName: string;
+    timestamp: {
+        st: string;
+        et: string;
+    };
+    response?: string;
+} & ({
+    status: 'pending';
+    audioFrames: Float32Array;
+    fileBlob?: undefined;
+} | {
+    status: 'success';
+    audioFrames?: undefined;
+    fileBlob?: undefined;
+} | {
+    status: 'failure';
+    fileBlob: Blob;
+    audioFrames?: undefined;
+});
+export type UploadProgressCallback = (success: string[], total: number) => void;
+export type TErrorCallback = (args: {
+    error_code?: ERROR_CODE;
+    status_code: number;
+    message: string;
+}) => void;
+export type TSessionStatus = {
+    [key: string]: {
+        api?: {
+            status: 'na' | 'init' | 'stop' | 'commit';
+            error?: string;
+            response?: string;
+            code: number;
+        };
+        vad?: {
+            status: 'start' | 'pause' | 'stop' | 'resume';
+        };
+    };
+};
+export type TFileUploadProgressCallback = (args: {
+    success: number;
+    total: number;
+    is_uploaded?: boolean;
+    fileName?: string;
+    chunkData?: Uint8Array<ArrayBufferLike>[];
+    error?: {
+        code: number;
+        msg: string;
+    };
+}) => void;

package/dist/constants/types.js

@@ -0,0 +1 @@
+export {};

package/dist/fetch-client/helper.d.ts

@@ -0,0 +1,11 @@
+declare const setEnv: ({ env, clientId, auth_token, }: {
+    env?: "PROD" | "DEV";
+    clientId?: string;
+    auth_token: string;
+}) => void;
+export declare const GET_EKA_HOST: () => string;
+export declare const GET_CLIENT_ID: () => string;
+export declare const GET_AUTH_TOKEN: () => string;
+export declare const GET_EKA_V2RX_HOST_V2: () => string;
+export declare const GET_EKA_V2RX_HOST_V3: () => string;
+export default setEnv;

package/dist/fetch-client/helper.js

@@ -0,0 +1,28 @@
+const DEV = {
+    EKA_HOST: 'https://api.dev.eka.care',
+    EKA_V2RX_HOST_V2: 'https://v2rxbe.dev.eka.care/voice/api/v2',
+    EKA_V2RX_HOST_V3: 'https://v2rxbe.dev.eka.care/voice/api/v3',
+};
+const PROD = {
+    EKA_HOST: 'https://api.eka.care',
+    EKA_V2RX_HOST_V2: 'https://api.eka.care/voice/api/v2',
+    EKA_V2RX_HOST_V3: 'https://api.eka.care/voice/api/v3',
+};
+let envVar = PROD;
+let client_id = 'doc-web';
+let auth;
+const setEnv = ({ env, clientId, auth_token, }) => {
+    if (env) {
+        envVar = env === 'PROD' ? PROD : DEV;
+    }
+    if (clientId) {
+        client_id = clientId;
+    }
+    auth = auth_token;
+};
+export const GET_EKA_HOST = () => envVar.EKA_HOST;
+export const GET_CLIENT_ID = () => client_id;
+export const GET_AUTH_TOKEN = () => auth;
+export const GET_EKA_V2RX_HOST_V2 = () => envVar.EKA_V2RX_HOST_V2;
+export const GET_EKA_V2RX_HOST_V3 = () => envVar.EKA_V2RX_HOST_V3;
+export default setEnv;

package/dist/fetch-client/index.d.ts

@@ -0,0 +1 @@
+export default function fetchWrapper(url: RequestInfo, options?: RequestInit | undefined, timeoutMs?: number): Promise<Response>;

package/dist/fetch-client/index.js

@@ -0,0 +1,36 @@
+import { GET_CLIENT_ID, GET_AUTH_TOKEN } from './helper';
+const API_TIMEOUT_MS = 5000;
+export default async function fetchWrapper(url, options = {}, timeoutMs = API_TIMEOUT_MS) {
+    const controller = new AbortController();
+    let timeoutId = null;
+    try {
+        // Set up timeout
+        timeoutId = setTimeout(() => {
+            controller.abort();
+        }, timeoutMs);
+        const newHeaders = new Headers(options.headers);
+        if (!newHeaders.get('client-id')) {
+            newHeaders.set('client-id', GET_CLIENT_ID());
+        }
+        if (!newHeaders.get('auth') && GET_AUTH_TOKEN()) {
+            newHeaders.set('auth', GET_AUTH_TOKEN());
+        }
+        const response = await fetch(url, {
+            ...options,
+            headers: newHeaders,
+            signal: controller.signal,
+            credentials: 'include',
+        });
+        return response;
+    }
+    catch (error) {
+        console.error(error);
+        throw error;
+    }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+import { TGetStatusResponse } from './api/get-voice-api-v3-status';
+import { TEndRecordingResponse, TErrorCallback, TFileUploadProgressCallback, TGetTransactionHistoryResponse, TPatchTransactionRequest, TPostTransactionResponse, TStartRecordingRequest } from './constants/types';
+declare class EkaScribe {
+    private static instance;
+    private vadInstance;
+    private audioFileManagerInstance;
+    private audioBufferInstance;
+    private constructor();
+    static getInstance({ access_token, env, clientId, }: {
+        access_token?: string;
+        env?: 'PROD' | 'DEV';
+        clientId?: string;
+    }): EkaScribe;
+    static resetInstance(): void;
+    getEkascribeConfig(): Promise<import("./constants/types").TGetConfigV2Response>;
+    updateAuthTokens({ access_token }: {
+        access_token: string;
+    }): void;
+    initTransaction(request: TStartRecordingRequest): Promise<import("./constants/types").TStartRecordingResponse>;
+    startRecording(): Promise<import("./constants/types").TStartRecordingResponse>;
+    reinitializeVad(): void;
+    pauseRecording(): import("./constants/types").TPauseRecordingResponse;
+    resumeRecording(): import("./constants/types").TPauseRecordingResponse;
+    endRecording(): Promise<TEndRecordingResponse>;
+    retryUploadRecording({ force_commit }: {
+        force_commit: boolean;
+    }): Promise<TEndRecordingResponse>;
+    patchSessionStatus({ sessionId, processing_status, processing_error, }: TPatchTransactionRequest): Promise<TPostTransactionResponse>;
+    commitTransactionCall(): Promise<TEndRecordingResponse>;
+    stopTransactionCall(): Promise<TEndRecordingResponse>;
+    getTemplateOutput({ txn_id }: {
+        txn_id: string;
+    }): Promise<TGetStatusResponse>;
+    getSessionHistory({ txn_count }: {
+        txn_count: number;
+    }): Promise<TGetTransactionHistoryResponse>;
+    getSuccessFiles(): string[];
+    getFailedFiles(): string[];
+    getTotalAudioFiles(): import("./constants/types").TAudioChunksInfo[];
+    resetEkaScribe(): void;
+    onError(callback: TErrorCallback): void;
+    onUserSpeechCallback(callback: (isSpeech: boolean) => void): void;
+    onFileUploadProgressCallback(callback: TFileUploadProgressCallback): void;
+    configureVadConstants({ pref_length, desp_length, max_length, sr, frame_size, pre_speech_pad_frames, short_thsld, long_thsld, }: {
+        pref_length: number;
+        desp_length: number;
+        max_length: number;
+        sr: number;
+        frame_size: number;
+        pre_speech_pad_frames: number;
+        short_thsld: number;
+        long_thsld: number;
+    }): void;
+}
+export declare const getEkaScribeInstance: ({ access_token, env, clientId, }: {
+    access_token?: string;
+    env?: "PROD" | "DEV";
+    clientId?: string;
+}) => EkaScribe;
+export {};