@cognigy/rest-api-client 0.14.0 → 0.15.0

package/build/shared/charts/descriptors/voice/mappers/record.mapper.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordMapper = void 0;
+/* Custom modules */
+const logger_1 = require("../../../../helper/logger");
+const base_mapper_1 = require("./base.mapper");
+class RecordMapper extends base_mapper_1.BaseMapper {
+    handleInput(input, api, isGenericNode = false) {
+        try {
+            switch (this.endpointType) {
+                case "audioCodes": {
+                    const output = this.handleAudioCodesInput(input, api);
+                    return this.buildPayload(output);
+                }
+                case "voiceGateway2":
+                default: {
+                    const output = this.handleVGInput(input, api);
+                    return this.buildPayload(output);
+                }
+            }
+        }
+        catch (err) {
+            const errorMessage = `Error in RecordMapper handleInput: ${err.message}`;
+            api.log("error", errorMessage);
+            throw Error(errorMessage);
+        }
+    }
+    handleVGInput(input, api) {
+        const { action, recordingId, siprecServerURL } = input;
+        /* base record options */
+        const recordOptions = {
+            action,
+        };
+        const storedActivity = api.getSystemContext("vgRecordAction");
+        if (recordingId) {
+            recordOptions.recordingID = recordingId;
+        }
+        switch (action) {
+            case "startCallRecording":
+                if (process.env.TMP_ENDPOINT_CALL_RECORDING_ENABLE_GLOBALLY !== "true") {
+                    if (storedActivity === "startCallRecording") {
+                        const errorText = "Cannot start recording when recording is already started";
+                        logger_1.default.error({}, errorText, {}, true);
+                        throw new Error(errorText);
+                    }
+                    else if (storedActivity === "resumeCallRecording") {
+                        const errorText = "Cannot start recording when recording is already resumed";
+                        logger_1.default.error({}, errorText, {}, true);
+                        throw new Error(errorText);
+                    }
+                    recordOptions.siprecServerURL = siprecServerURL;
+                }
+                break;
+            case "pauseCallRecording":
+                if (storedActivity !== "startCallRecording" && process.env.TMP_ENDPOINT_CALL_RECORDING_ENABLE_GLOBALLY !== "true") {
+                    const errorText = "Cannot pause recording when recording is not started";
+                    logger_1.default.error({}, errorText, {}, true);
+                    throw new Error(errorText);
+                }
+                break;
+            case "stopCallRecording":
+                if (storedActivity !== "startCallRecording" && storedActivity !== "resumeCallRecording" && process.env.TMP_ENDPOINT_CALL_RECORDING_ENABLE_GLOBALLY !== "true") {
+                    const errorText = "Cannot stop recording when recording is not started or paused";
+                    logger_1.default.error({}, errorText, {}, true);
+                    throw new Error(errorText);
+                }
+                break;
+            case "resumeCallRecording":
+                if (storedActivity === "resumeCallRecording") {
+                    const warnText = "Cannot resume recording when recording is already resumed";
+                    logger_1.default.warn({}, warnText, {}, true);
+                }
+                else if (storedActivity !== "pauseCallRecording") {
+                    const errorText = "Cannot resume recording when recording is not paused";
+                    logger_1.default.error({}, errorText, {}, true);
+                    throw new Error(errorText);
+                }
+                break;
+            default:
+                throw new Error(`Call Recording - invalid action: ${action}`);
+        }
+        /* Store the action in the context to send proper warnings */
+        api.setSystemContext("vgRecordAction", action);
+        const output = {
+            config: {
+                record: recordOptions
+            }
+        };
+        return output;
+    }
+    handleAudioCodesInput(input, api) {
+        return {};
+    }
+}
+exports.RecordMapper = RecordMapper;
+//# sourceMappingURL=record.mapper.js.map

package/build/shared/charts/descriptors/voice/mappers/sendMetadata.mapper.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMetadata = void 0;
+const helper_1 = require("../../voicegateway2/utils/helper");
+exports.sendMetadata = {
+    handleInput(endpointType, metadata) {
+        if (!(0, helper_1.isValidJSON)(metadata)) {
+            throw new Error("Invalid JSON in Metadata Field");
+        }
+        if (JSON.stringify(metadata) === '{}') {
+            throw new Error("Nothing is set in Metadata Field");
+        }
+        switch (endpointType) {
+            case "audioCodes":
+                return this.handleAudioCodesInput(metadata);
+            case "voiceGateway2":
+            default:
+                return this.handleVGInput(metadata);
+        }
+    },
+    handleVGInput(metadata) {
+        const voiceGateway2Payload = {
+            "sip:request": {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: "",
+                method: "INFO",
+                actionHook: "/info",
+            },
+        };
+        voiceGateway2Payload["sip:request"].body = JSON.stringify(metadata);
+        return {
+            _voiceGateway2: {
+                json: Object.assign({}, voiceGateway2Payload)
+            }
+        };
+    },
+    handleAudioCodesInput(metadata) {
+        return {
+            _voiceGateway: {
+                json: {
+                    activities: [{
+                            type: "event",
+                            name: "sendMetaData",
+                            value: metadata
+                        }]
+                }
+            }
+        };
+    }
+};
+//# sourceMappingURL=sendMetadata.mapper.js.map

package/build/shared/charts/descriptors/voice/mappers/setSessionConfig.mapper.js

@@ -3,11 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setSessionConfig = exports.vg2PayloadToActivityParams = exports.voiceConfigParamsToVoiceSettings = void 0;
 const strip_nulls_1 = require("../../voicegateway2/utils/strip-nulls");
 const helper_1 = require("../utils/helper");
-const constants_1 = require("../utils/constants");
 function voiceConfigParamsToVoiceSettings(config, api) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     let voiceSettings = {};
-    if (config.bargeInOnSpeech || config.bargeInOnDtmf) {
+    if (typeof config.bargeInOnDtmf === 'boolean' || typeof config.bargeInOnSpeech === 'boolean') {
         voiceSettings.bargeIn = {
             bargeInEnable: false,
             bargeInOnDtmf: (_a = config.bargeInOnDtmf) !== null && _a !== void 0 ? _a : false,
@@ -21,25 +20,65 @@ function voiceConfigParamsToVoiceSettings(config, api) {
         mode: config.sttVadMode,
         voiceMs: config.sttVadVoiceMs,
     };
+    let hints = [];
+    if (config.sttHintsDynamicHints) {
+        if (Array.isArray(config.sttHintsDynamicHints) && ((_c = config.sttHintsDynamicHints) === null || _c === void 0 ? void 0 : _c.length)) {
+            hints = [...config.sttHintsDynamicHints];
+        }
+        else {
+            throw new Error(`Error adding dynamic hints. Context or input is not an array`);
+        }
+    }
+    if (config.sttHints && config.sttHints.length) {
+        hints = [...hints, ...config.sttHints];
+    }
     // stt (recognizer)
     voiceSettings.stt = {
         sttVendor: config.sttVendor,
         sttLanguage: config.sttLanguage,
-        sttHints: config.sttHints,
+        sttHints: hints,
         sttDisablePunctuation: config.sttDisablePunctuation !== undefined &&
             config.sttDisablePunctuation !== null
             ? !config.sttDisablePunctuation
-            : undefined,
+            : undefined
     };
     // tts (synthesizer)
     voiceSettings.tts = {
         ttsVendor: config.ttsVendor,
         ttsLanguage: config.ttsLanguage,
         ttsVoice: config.ttsVoice,
-        azureServiceEndpoint: config.azureTtsDeploymentId
+        azureServiceEndpoint: config.azureTtsDeploymentId,
+        ttsDisableCache: config.ttsDisableCache,
     };
-    if (config.ttsVendor === 'microsoft' && config.azureTtsDeploymentId)
-        voiceSettings.tts.azureServiceEndpoint = config.azureTtsDeploymentId;
+    if (config.ttsVendor === "microsoft") {
+        if (config.azureTtsDeploymentId) {
+            voiceSettings.tts.azureServiceEndpoint = config.azureTtsDeploymentId;
+        }
+    }
+    if (config.sttVendor === "microsoft") {
+        if (config.recognizeLanguagesAzure) {
+            voiceSettings.stt.altLanguages = [];
+            const languages = [config.sttAzureLang1, config.sttAzureLang2, config.sttAzureLang3];
+            languages.map(language => {
+                var _a, _b;
+                if (language && (language === null || language === void 0 ? void 0 : language.length) > 0) {
+                    (_b = (_a = voiceSettings.stt) === null || _a === void 0 ? void 0 : _a.altLanguages) === null || _b === void 0 ? void 0 : _b.push(language);
+                }
+            });
+        }
+    }
+    if (config.sttVendor === "google") {
+        if (config.recognizeLanguagesGoogle) {
+            voiceSettings.stt.altLanguages = [];
+            const languages = [config.sttGoogleLang1, config.sttGoogleLang2, config.sttGoogleLang3];
+            languages.map(language => {
+                var _a, _b;
+                if (language && (language === null || language === void 0 ? void 0 : language.length) > 0) {
+                    (_b = (_a = voiceSettings.stt) === null || _a === void 0 ? void 0 : _a.altLanguages) === null || _b === void 0 ? void 0 : _b.push(language);
+                }
+            });
+        }
+    }
     // userNoInput
     voiceSettings.userNoInput = {
         userNoInputMode: config.userNoInputMode,
@@ -53,7 +92,7 @@ function voiceConfigParamsToVoiceSettings(config, api) {
         dtmfInterDigitTimeout: config.dtmfInterDigitTimeout,
         dtmfMaxDigits: config.dtmfMaxDigits,
         dtmfMinDigits: config.dtmfMinDigits,
-        dtmfSubmitDigit: (_c = config.dtmfSubmitDigit) === null || _c === void 0 ? void 0 : _c.trim(),
+        dtmfSubmitDigit: (_d = config.dtmfSubmitDigit) === null || _d === void 0 ? void 0 : _d.trim(),
     };
     if (config === null || config === void 0 ? void 0 : config.dtmfEnable) {
         if (voiceSettings.dtmf.dtmfSubmitDigit &&
@@ -118,34 +157,32 @@ function vg2PayloadToActivityParams(payload) {
 exports.vg2PayloadToActivityParams = vg2PayloadToActivityParams;
 exports.setSessionConfig = {
     handleInput(endpointType, voiceSettings) {
-        if (endpointType === constants_1.ENDPOINTS.VOICE_GATEWAY) {
-            return this.handleVGInput(voiceSettings);
-        }
-        else if (endpointType === constants_1.ENDPOINTS.AUDIO_CODES) {
-            return this.handleAudioCodesInput(voiceSettings);
-        }
-        else {
-            return this.handleVGInput(voiceSettings);
+        switch (endpointType) {
+            case "audioCodes":
+                return this.handleAudioCodesInput(voiceSettings);
+            case "voiceGateway2":
+            default:
+                return this.handleVGInput(voiceSettings);
         }
     },
-    handleVGInput(voiceSettings) {
-        var _a;
+    handleVGInput(voiceSettings, sessionParams, api) {
         const { bargeIn, continuousAsr, stt, tts, userNoInput, dtmf, vad, azureConfig, } = voiceSettings;
         const user = {};
         const synthesizer = {};
         const recognizer = {};
-        const barge = {};
-        let dtmfParam;
         //verify if there are STT Configs to set
         recognizer.language = (stt === null || stt === void 0 ? void 0 : stt.sttLanguage) || undefined;
         recognizer.hints = (stt === null || stt === void 0 ? void 0 : stt.sttHints) ? stt.sttHints : undefined;
         if (recognizer.hints && recognizer.hints !== undefined) {
             recognizer.hintsBoost = (stt === null || stt === void 0 ? void 0 : stt.sttHintsBoost) || 20;
         }
-        recognizer.vendor = (stt === null || stt === void 0 ? void 0 : stt.sttVendor) ? stt.sttVendor : "default";
+        recognizer.vendor = (stt === null || stt === void 0 ? void 0 : stt.sttVendor) ? stt.sttVendor : undefined;
         recognizer.punctuation = stt === null || stt === void 0 ? void 0 : stt.sttDisablePunctuation;
         recognizer.azureSttEndpointId = azureConfig === null || azureConfig === void 0 ? void 0 : azureConfig.azureSttContextId;
         recognizer.audioLogging = azureConfig === null || azureConfig === void 0 ? void 0 : azureConfig.azureEnableAudioLogging;
+        if (recognizer.vendor && (recognizer.vendor === 'microsoft' || recognizer.vendor === 'google')) {
+            recognizer.altLanguages = (stt === null || stt === void 0 ? void 0 : stt.altLanguages) || [];
+        }
         if (vad) {
             recognizer.vad = { enable: vad.enable };
             if (vad.enable) {
@@ -162,15 +199,21 @@ exports.setSessionConfig = {
         }
         //verify if there are No User Input Configs to set
         if (userNoInput) {
-            user.noInputMode = userNoInput.userNoInputMode;
-            if (userNoInput.userNoInputMode === "speech" &&
-                userNoInput.userNoInputSpeech)
-                user.noInputSpeech = userNoInput.userNoInputSpeech;
-            if (userNoInput.userNoInputMode === "play" && userNoInput.userNoInputUrl)
-                user.noInputUrl = userNoInput.userNoInputUrl;
-            user.noInputRetries = userNoInput.userNoInputRetries || 0;
-            user.noInputTimeout = userNoInput.userNoInputTimeout
-                ? userNoInput.userNoInputTimeout / 1000
+            const { userNoInputRetries, userNoInputMode, userNoInputSpeech, userNoInputTimeout, userNoInputUrl } = userNoInput || {};
+            user.noInputMode = userNoInputMode;
+            if (userNoInputMode === "speech" && userNoInputSpeech)
+                user.noInputSpeech = userNoInputSpeech;
+            if (userNoInputMode === "play" && userNoInputUrl)
+                user.noInputUrl = userNoInputUrl;
+            /* User No Input Retries. min: 0, max: 999*/
+            if (userNoInputRetries < 0 || userNoInputRetries > 999) {
+                user.noInputRetries = 1;
+            }
+            else {
+                user.noInputRetries = userNoInputRetries !== null && userNoInputRetries !== void 0 ? userNoInputRetries : 1;
+            }
+            user.noInputTimeout = userNoInputTimeout
+                ? userNoInputTimeout / 1000
                 : 10;
         }
         // verify if there are Continuous ASR Configs to set
@@ -181,58 +224,69 @@ exports.setSessionConfig = {
                 : undefined;
         }
         // verify if there are Barge In Configs to set
+        let barge = {};
         if (bargeIn) {
-            barge.enable = bargeIn.bargeInEnable;
-            /* Barge in minimum words. min: 1, max: 5, default: 1 */
-            bargeIn.bargeInMinimunWords >= 1 && bargeIn.bargeInMinimunWords <= 5
-                ? (barge.minBargeinWordCount = bargeIn.bargeInMinimunWords)
-                : (barge.minBargeinWordCount = 1);
-            barge.input = [];
-            barge.actionHook = "voice";
-            barge.dtmfBargein = bargeIn.bargeInOnDtmf;
-            if (barge.dtmfBargein) {
-                barge.enable = true;
+            const { bargeInOnSpeech, bargeInOnDtmf, bargeInMinimunWords = 1 } = bargeIn;
+            barge = {
+                enable: bargeInOnSpeech || bargeInOnDtmf,
+                actionHook: "voice",
+                dtmfBargein: bargeInOnDtmf,
+                input: [],
+            };
+            if (bargeInOnDtmf) {
                 barge.input.push("digits");
             }
-            if (bargeIn.bargeInOnSpeech) {
-                barge.enable = true;
+            if (bargeInOnSpeech) {
+                /* Barge in minimum words. min: 1, max: 5, default: 1 */
+                if (bargeInMinimunWords >= 1 && bargeInMinimunWords <= 5) {
+                    barge.minBargeinWordCount = bargeInMinimunWords;
+                }
                 barge.input.push("speech");
             }
         }
-        // verify if there are DTMF Configs to set
+        let enableDTMF;
+        // verify if there are DTMF Configs to set		
         if (dtmf) {
-            dtmfParam = dtmf.dtmfEnable;
-            if (dtmf.dtmfEnable) {
-                barge.enable = (_a = barge.enable) !== null && _a !== void 0 ? _a : false;
-                barge.interDigitTimeout =
-                    dtmf.dtmfInterDigitTimeout && dtmf.dtmfInterDigitTimeout >= 0
-                        ? dtmf.dtmfInterDigitTimeout === 0
-                            ? 0
-                            : dtmf.dtmfInterDigitTimeout / 1000
-                        : undefined;
+            const { dtmfEnable, dtmfInterDigitTimeout = 0, dtmfMaxDigits, dtmfMinDigits, dtmfSubmitDigit } = dtmf;
+            enableDTMF = dtmfEnable;
+            if (dtmfEnable) {
+                barge = Object.assign(Object.assign({}, barge), { maxDigits: 1, minDigits: dtmfMinDigits || 1, finishOnKey: dtmfSubmitDigit });
+                if (typeof dtmfInterDigitTimeout === "number") {
+                    if (dtmfInterDigitTimeout > 0) {
+                        barge.interDigitTimeout = dtmfInterDigitTimeout / 1000;
+                    }
+                }
                 /* Max digits. min: 1, max: - default: 1 */
-                barge.maxDigits =
-                    dtmf.dtmfMaxDigits >= 1 ? (barge.maxDigits = dtmf.dtmfMaxDigits) : 1;
-                barge.minDigits = dtmf.dtmfMinDigits || 1;
-                barge.finishOnKey = dtmf.dtmfSubmitDigit;
+                if (dtmfMaxDigits >= 1) {
+                    barge.maxDigits = dtmf.dtmfMaxDigits;
+                }
             }
         }
         // Check if there are configs for synthesizer, recognizer and bargeIn
-        const voiceConfig = {
+        let voiceConfig = {
             synthesizer: synthesizer || undefined,
             recognizer: recognizer || undefined,
             bargeIn: barge || undefined,
         };
-        (0, strip_nulls_1.stripNulls)(voiceConfig);
-        if (voiceConfig.synthesizer && !voiceConfig.synthesizer.azureServiceEndpoint)
+        if (voiceConfig.synthesizer && !voiceConfig.synthesizer.azureServiceEndpoint) {
             voiceConfig.synthesizer.azureServiceEndpoint = "";
-        if (voiceConfig.recognizer && !voiceConfig.recognizer.azureSttEndpointId)
+        }
+        if (voiceConfig.recognizer && !voiceConfig.recognizer.azureSttEndpointId) {
             voiceConfig.recognizer.azureSttEndpointId = "";
+        }
+        (0, strip_nulls_1.stripNulls)(voiceConfig);
+        /* As the last step we check the session params JSON for valid properties */
+        if (sessionParams) {
+            voiceConfig.sessionParams = sessionParams;
+        }
         // Check if there are configs for No User Input and DTMF
         const cognigyConfig = {
-            user: user ? user : undefined,
-            dtmf: dtmfParam,
+            user: user || undefined,
+            dtmf: enableDTMF,
         };
+        if (tts && typeof tts.ttsDisableCache === "boolean") {
+            cognigyConfig.disableTtsCache = tts.ttsDisableCache;
+        }
         (0, strip_nulls_1.stripNulls)(cognigyConfig);
         const prePayload = {
             cognigyConfig: Object.keys(cognigyConfig).length
@@ -242,9 +296,15 @@ exports.setSessionConfig = {
                 ? voiceConfig
                 : undefined,
         };
+        if (prePayload.cognigyConfig === undefined) {
+            delete prePayload.cognigyConfig;
+        }
+        if (prePayload.voiceGateway2Config === undefined) {
+            delete prePayload.voiceGateway2Config;
+        }
         const payload = {
             _voiceGateway2: {
-                json: (0, strip_nulls_1.stripNulls)(prePayload),
+                json: Object.assign({}, prePayload),
             },
         };
         return payload;
@@ -286,7 +346,9 @@ exports.setSessionConfig = {
         if (bargeIn) {
             sessionParams.bargeIn = bargeIn.bargeInOnSpeech;
             sessionParams.bargeInOnDTMF = bargeIn.bargeInOnDtmf;
-            sessionParams.bargeInMinWordCount = bargeIn.bargeInMinimunWords;
+            if (bargeIn.bargeInMinimunWords >= 1 && bargeIn.bargeInMinimunWords <= 5) {
+                sessionParams.bargeInMinWordCount = bargeIn.bargeInMinimunWords || 1;
+            }
             if (sessionParams.bargeInOnDTMF)
                 sessionParams.sendDTMF = true;
         }

package/build/shared/charts/descriptors/voice/mappers/transfer.mapper.js

@@ -4,14 +4,13 @@ exports.prepareTransferParams = exports.transfer = void 0;
 /* Node modules */
 const path_1 = require("path");
 /* Custom modules */
-const constants_1 = require("../utils/constants");
 const helper_1 = require("../../../descriptors/voicegateway2/utils/helper");
 const helper_2 = require("../utils/helper");
 exports.transfer = {
-    handleInput(endpointType, params, isGenericNode) {
+    handleInput(endpointType, params, isGenericNode, recognitionChannel, sttVendor, sttLanguage) {
         try {
             switch (endpointType) {
-                case constants_1.ENDPOINTS.AUDIO_CODES:
+                case "audioCodes":
                     if (isGenericNode && params.transferSipHeaders) {
                         let headers = [];
                         for (const [key, value] of Object.entries(params.transferSipHeaders)) {
@@ -24,17 +23,17 @@ exports.transfer = {
                         params.transferSipHeaders = headers;
                     }
                     return this.handleAudioCodesInput((0, exports.prepareTransferParams)(params));
-                case constants_1.ENDPOINTS.VOICE_GATEWAY:
+                case "voiceGateway2":
                 default:
-                    return this.handleVGInput((0, exports.prepareTransferParams)(params));
+                    return this.handleVGInput((0, exports.prepareTransferParams)(params), recognitionChannel, sttVendor, sttLanguage);
             }
         }
         catch (error) {
             throw Error(error.message);
         }
     },
-    handleVGInput(transferParam) {
-        const { transferType, transferTarget, transferReason, useTransferSipHeaders, transferSipHeaders, dialMusic, dialTranscriptionWebhook, dialCallerId } = transferParam;
+    handleVGInput(transferParam, recognitionChannel, sttVendor, sttLanguage) {
+        const { transferType, transferTarget, transferReason, useTransferSipHeaders, transferSipHeaders, dialMusic, dialTranscriptionWebhook, dialCallerId, amdEnabled, amdRedirectOnMachineDetected, amdRedirectText, } = transferParam;
         const payload = {
             _voiceGateway2: {
                 json: {}
@@ -53,6 +52,16 @@ exports.transfer = {
                     headers,
                     target: [],
                 };
+                if (amdEnabled) {
+                    dialVerb.amd = {
+                        actionHook: "amd"
+                    };
+                    dialVerb.amdConfig = {
+                        amdEnabled,
+                        amdRedirectOnMachineDetected,
+                        amdRedirectText,
+                    };
+                }
                 const phoneTarget = {
                     type: "phone",
                     number: (0, helper_1.cleanTarget)(transferTarget, false),
@@ -67,21 +76,42 @@ exports.transfer = {
                 if (transferTarget === null || transferTarget === void 0 ? void 0 : transferTarget.includes("@")) {
                     dialVerb.target = [sipTarget];
                 }
+                const transcribeVerb = {};
+                const recognizer = {};
                 if (dialTranscriptionWebhook === null || dialTranscriptionWebhook === void 0 ? void 0 : dialTranscriptionWebhook.length) {
                     if (!(0, helper_2.isValidUrl)(dialTranscriptionWebhook)) {
                         throw new Error(`Transcription webhook URL is invalid ${dialTranscriptionWebhook}`);
                     }
-                    const transcribeVerb = {
-                        transcriptionHook: dialTranscriptionWebhook,
-                    };
+                    transcribeVerb.transcriptionHook = dialTranscriptionWebhook;
+                    switch (recognitionChannel) {
+                        case 0:
+                            recognizer.separateRecognitionPerChannel = true;
+                            break;
+                        case 1:
+                            recognizer.separateRecognitionPerChannel = false;
+                            break;
+                        case 2:
+                            recognizer.separateRecognitionPerChannel = true;
+                            transcribeVerb.channel = 2;
+                            break;
+                    }
+                    if (sttVendor) {
+                        recognizer.vendor = sttVendor;
+                        recognizer.language = sttLanguage;
+                    }
+                }
+                if (Object.keys(transcribeVerb).length > 0) {
                     dialVerb.transcribe = transcribeVerb;
+                    if (Object.keys(recognizer).length > 0) {
+                        transcribeVerb.recognizer = recognizer;
+                    }
                 }
                 if (dialMusic === null || dialMusic === void 0 ? void 0 : dialMusic.length) {
                     if (!(0, helper_2.isValidUrl)(dialMusic)) {
                         throw new Error(`Audio file URL is invalid ${dialMusic}`);
                     }
                     const extension = (0, path_1.extname)(dialMusic);
-                    if (extension !== (".mp3" || ".wav")) {
+                    if ([".mp3", ".wav"].indexOf(extension) === -1) {
                         throw new Error(`Audio file must be from type .mp3 or .wav. Extension was: ${extension}`);
                     }
                     dialVerb.dialMusic = dialMusic;

package/build/shared/charts/descriptors/voice/nodes/bargeIn.js

@@ -14,27 +14,27 @@ exports.BARGE_IN = (0, createNodeDescriptor_1.createNodeDescriptor)({
     appearance: {
         color: design_1.nodeColor,
     },
-    summary: "Enables Barge In for the entire call session",
+    summary: "UI__NODE_EDITOR__BARGE_IN__SUMMARY",
     fields: [
         {
             key: "bargeInOnSpeech",
             type: "toggle",
-            label: "Barge In On Speech",
-            description: "Allows the user to interrupt bot output with speech",
+            label: "UI__NODE_EDITOR__BARGE_IN__FIELDS__BARGE_IN_ON_SPEECH__LABEL",
+            description: "UI__NODE_EDITOR__BARGE_IN__FIELDS__BARGE_IN_ON_SPEECH__DESCRIPTION",
             defaultValue: false,
         },
         {
             key: "bargeInOnDtmf",
             type: "toggle",
-            label: "Barge In On DTMF",
-            description: "Allows the user to interrupt bot output with DTMF. Enabling Barge in on DTMF will also enable DTMF capture.",
+            label: "UI__NODE_EDITOR__BARGE_IN__FIELDS__BARGE_IN_ON_DTMF__LABEL",
+            description: "UI__NODE_EDITOR__BARGE_IN__FIELDS__BARGE_IN_ON_DTMF__DESCRIPTION",
             defaultValue: false,
         },
         {
             key: "bargeInMinWordCount",
             type: "slider",
-            label: "Barge In Minimum Words",
-            description: "Defines the minimum number of words that the user must say for the Voice Gateway to consider it a barge in",
+            label: "UI__NODE_EDITOR__BARGE_IN__FIELDS__BARGE_IN_MIN_WORD_COUNT__LABEL",
+            description: "UI__NODE_EDITOR__BARGE_IN__FIELDS__BARGE_IN_MIN_WORD_COUNT__DESCRIPTION",
             defaultValue: 1,
             params: {
                 min: 1,
@@ -45,8 +45,8 @@ exports.BARGE_IN = (0, createNodeDescriptor_1.createNodeDescriptor)({
         {
             key: "dtmfInterDigitTimeout",
             type: "number",
-            label: "DTMF Inter Digit Timeout",
-            description: "Defines the timeout in between collected DTMF digits",
+            label: "UI__NODE_EDITOR__BARGE_IN__FIELDS__DTMF_INTER_DIGIT_TIMEOUT__LABEL",
+            description: "UI__NODE_EDITOR__BARGE_IN__FIELDS__DTMF_INTER_DIGIT_TIMEOUT__DESCRIPTION",
             defaultValue: 2000,
             params: {
                 min: 0,
@@ -55,8 +55,8 @@ exports.BARGE_IN = (0, createNodeDescriptor_1.createNodeDescriptor)({
         {
             key: "dtmfMaxDigits",
             type: "number",
-            label: "DTMF Max Digits",
-            description: "Defines the maximum number of digits which can be entered by the user, the digits are being submitted automatically once this limit is reached",
+            label: "UI__NODE_EDITOR__BARGE_IN__FIELDS__DTMF_MAX_DIGITS__LABEL",
+            description: "UI__NODE_EDITOR__BARGE_IN__FIELDS__DTMF_MAX_DIGITS__DESCRIPTION",
             defaultValue: 1,
             params: {
                 min: 1,
@@ -65,15 +65,15 @@ exports.BARGE_IN = (0, createNodeDescriptor_1.createNodeDescriptor)({
         {
             key: "dtmfSubmitDigit",
             type: "cognigyText",
-            label: "DTMF Submit Digit",
-            description: "Defines the DTMF submit digit which will be used for submitting the previously entered digits.",
+            label: "UI__NODE_EDITOR__BARGE_IN__FIELDS__DTMF_SUBMIT_DIGIT__LABEL",
+            description: "UI__NODE_EDITOR__BARGE_IN__FIELDS__DTMF_SUBMIT_DIGIT__DESCRIPTION",
             defaultValue: "#",
         },
     ],
     sections: [
         {
             key: "paramsDtmf",
-            label: "DTMF",
+            label: "UI__NODE_EDITOR__BARGE_IN__SECTIONS__PARAMS_DTMF__LABEL",
             defaultCollapsed: false,
             fields: ["dtmfInterDigitTimeout", "dtmfMaxDigits", "dtmfSubmitDigit"],
             condition: {
@@ -92,12 +92,6 @@ exports.BARGE_IN = (0, createNodeDescriptor_1.createNodeDescriptor)({
         const { api, input } = cognigy;
         const { endpointType } = input;
         try {
-            if (config.bargeInOnDtmf) {
-                config.dtmfEnable = true;
-            }
-            if (config.bargeInOnSpeech || config.bargeInOnDtmf) {
-                config.bargeInEnable = true;
-            }
             const payload = setSessionConfig_mapper_1.setSessionConfig.handleInput(endpointType, (0, setSessionConfig_mapper_2.voiceConfigParamsToVoiceSettings)(config, api));
             /* we need to store this for the DTMF Collect - Config node */
             api.setSystemContext("vgSettings", { bargeInOnDtmf: config.bargeInOnDtmf });