@cognigy/rest-api-client 0.20.0 → 4.94.0

package/dist/esm/shared/charts/descriptors/voice/mappers/setSessionConfig.mapper.js

@@ -0,0 +1,644 @@
+/* Node modules */
+import { BaseMapper } from "./base.mapper";
+import { stripNulls } from "../../voicegateway2/utils/strip-nulls";
+import { isValidDTMF, isValidUrl } from "../utils/helper";
+class SessionConfigMapper extends BaseMapper {
+    buildUser(sessionParams, userNoInput) {
+        const { userNoInputRetries, userNoInputMode, userNoInputSpeech, userNoInputTimeout, userNoInputUrl, userNoInputTimeoutEnable } = userNoInput || {};
+        const { user: sessionParamsUser } = sessionParams || {};
+        const { noInputSpeech, noInputUrl, noInputRetries, noInputTimeout, noInputMode } = sessionParamsUser || {};
+        const user = {};
+        /* verify if there are No User Input Configs to set */
+        if (userNoInput || sessionParamsUser) {
+            /* Either userNoInputTimeoutEnable is true, or the 'user' object is defined in the session params  */
+            if (userNoInputTimeoutEnable === true || this.has(sessionParamsUser)) {
+                user.noInputMode = noInputMode || userNoInputMode;
+                switch (user.noInputMode) {
+                    case "speech":
+                        user.noInputSpeech = noInputSpeech || userNoInputSpeech;
+                        break;
+                    case "play":
+                        user.noInputUrl = noInputUrl || userNoInputUrl;
+                        break;
+                    default:
+                        break;
+                }
+                const retries = Number(noInputRetries) || Number(userNoInputRetries);
+                /* User No Input Retries. min: 0, max: 999 - if invalid range: set to 1 */
+                if (retries < 0 || retries > 999 || isNaN(retries)) {
+                    user.noInputRetries = 1;
+                }
+                else {
+                    user.noInputRetries = retries;
+                }
+                const timeout = Number(noInputTimeout) || Number(userNoInputTimeout);
+                if (timeout < 0 || isNaN(timeout)) {
+                    user.noInputTimeout = 10;
+                }
+                else {
+                    user.noInputTimeout = timeout / 1000;
+                }
+            }
+            else if (userNoInputTimeoutEnable === false && !this.has(sessionParamsUser)) {
+                user.noInputTimeout = 0;
+            }
+        }
+        return user;
+    }
+    buildFlow(sessionParams, flowNoInput) {
+        const { flowNoInputMode, flowNoInputRetries, flowNoInputSpeech, flowNoInputTimeout, flowNoInputTimeoutEnable, flowNoInputUrl, flowNoInputFail } = flowNoInput || {};
+        const { flow: sessionParamsFlow } = sessionParams || {};
+        const { flowNoInputEnable: spEnable, flowNoInputFail: spFail, flowNoInputMode: spMode, flowNoInputRetries: spRetries, flowNoInputSpeech: spSpeech, flowNoInputTimeout: spTimeout, flowNoInputUrl: spUrl } = sessionParamsFlow || {};
+        const flow = {};
+        // verify if there are No Flow Input Configs to set
+        if (flowNoInput || sessionParamsFlow) {
+            const enabled = spEnable === true || flowNoInputTimeoutEnable === true;
+            flow.flowNoInputEnable = enabled;
+            if (!enabled)
+                return flow;
+            if (enabled) {
+                flow.flowNoInputMode = spMode || flowNoInputMode;
+                flow.flowNoInputFail = spFail || flowNoInputFail;
+                switch (flow.flowNoInputMode) {
+                    case "speech":
+                        flow.flowNoInputSpeech = spSpeech || flowNoInputSpeech;
+                        break;
+                    case "play":
+                        flow.flowNoInputUrl = spUrl || flowNoInputUrl;
+                        break;
+                    default:
+                        break;
+                }
+                const retries = Number(spRetries) || Number(flowNoInputRetries);
+                /* User No Input Retries. min: 0, max: 999  - if invalid range: set to 1 */
+                if (retries <= 1 || retries > 999 || isNaN(retries)) {
+                    flow.flowNoInputRetries = 1;
+                }
+                else {
+                    flow.flowNoInputRetries = retries;
+                }
+                const timeout = Number(spTimeout) || Number(flowNoInputTimeout);
+                if (timeout < 0 || isNaN(timeout)) {
+                    flow.flowNoInputTimeout = 10;
+                }
+                else {
+                    flow.flowNoInputTimeout = timeout / 1000;
+                }
+            }
+            else if (!enabled && !this.has(sessionParamsFlow)) {
+                flow.flowNoInputTimeout = 0;
+            }
+        }
+        return flow;
+    }
+    buildBarge(sessionParams, dtmf, bargeIn) {
+        const { dtmf: sessionParamsDtmf, bargeIn: sessionParamsBargeIn } = sessionParams || {};
+        const { bargeInOnSpeech, bargeInOnDtmf, bargeInMinimumWords } = bargeIn || {};
+        const { bargeInOnSpeech: spSpeech, bargeInOnDtmf: spDtmf, bargeInMinimumWords: spMinWordCount } = sessionParamsBargeIn || {};
+        const { dtmfEnable, dtmfInterDigitTimeout, dtmfMaxDigits, dtmfMinDigits, dtmfSubmitDigit } = dtmf || {};
+        const { dtmfEnable: spEnable, dtmfInterDigitTimeout: spTimeout, dtmfMaxDigits: spMaxDigits, dtmfMinDigits: spMinDigits, dtmfSubmitDigit: spSubmitDigit } = sessionParamsDtmf || {};
+        let barge = {};
+        if (this.has(bargeIn) || this.has(sessionParamsBargeIn)) {
+            const speechEnabled = spSpeech || bargeInOnSpeech;
+            const dtmfEnabled = spDtmf || bargeInOnDtmf;
+            barge = {
+                enable: speechEnabled || bargeInOnDtmf,
+                actionHook: "voice",
+                dtmfBargein: dtmfEnabled,
+                input: [],
+            };
+            if (dtmfEnabled) {
+                barge.input.push("digits");
+            }
+            if (speechEnabled) {
+                const minWords = spMinWordCount || bargeInMinimumWords || 1;
+                /* Barge in minimum words. min: 1, max: 5, default: 1 */
+                if (minWords >= 1 && minWords <= 5) {
+                    barge.minBargeinWordCount = minWords;
+                }
+                barge.input.push("speech");
+            }
+        }
+        if (dtmfEnable || spEnable) {
+            barge = Object.assign(Object.assign({}, barge), { maxDigits: 1, minDigits: Number(spMinDigits) || Number(dtmfMinDigits) || 1, finishOnKey: spSubmitDigit || dtmfSubmitDigit });
+            const timeout = Number(spTimeout) || Number(dtmfInterDigitTimeout) || 0;
+            if (timeout > 0) {
+                barge.interDigitTimeout = timeout / 1000;
+            }
+            /* Max digits. min: 1, max: - default: 1 */
+            const max = Number(spMaxDigits) || Number(dtmfMaxDigits);
+            if (max >= 1) {
+                barge.maxDigits = max;
+            }
+        }
+        return barge;
+    }
+    recognizerApplyContinuousAsr(sessionParams, recognizer, continuousAsr) {
+        const { continuousAsr: sessionParamsContinuousAsr } = sessionParams || {};
+        const { asrEnabled, asrDigit, asrTimeout = 0 } = continuousAsr || {};
+        const { asrDigit: spAsrDigit, asrEnabled: spAsrEnabled, asrTimeout: spAsrTimeout = 0 } = sessionParamsContinuousAsr || {};
+        // verify if there are Continuous ASR Configs to set
+        if (spAsrEnabled || asrEnabled) {
+            recognizer.asrDtmfTerminationDigit = spAsrDigit || asrDigit;
+            const timeout = Number(spAsrTimeout || asrTimeout);
+            recognizer.asrTimeout = timeout / 1000 || undefined;
+        }
+        return recognizer;
+    }
+    isDtmfEnabled(sessionParams, dtmf) {
+        const { dtmf: sessionParamsDtmf } = sessionParams || {};
+        const { dtmfEnable } = dtmf || {};
+        const { dtmfEnable: spEnable } = sessionParamsDtmf || {};
+        if (dtmf && (typeof dtmfEnable === "boolean" || typeof spEnable === "boolean")) {
+            return dtmfEnable === true || spEnable === true;
+        }
+        return undefined;
+    }
+    buildSynthesizer(sessionParams, tts) {
+        const { synthesizer: sessionParamsTts } = sessionParams || {};
+        const { vendor: spVendor, language: spLanguage, voice: spVoice, label: spLabel, model: spModel, azureServiceEndpoint: spAzureServiceEndpoint } = sessionParamsTts || {};
+        const { azureServiceEndpoint, ttsLabel, ttsLanguage, ttsModel, ttsVendor, ttsVoice } = tts || {};
+        const synthesizer = {};
+        if (this.has(tts) || this.has(sessionParamsTts)) {
+            synthesizer.vendor = spVendor || ttsVendor;
+            synthesizer.language = spLanguage || ttsLanguage;
+            synthesizer.voice = spVoice || ttsVoice;
+            synthesizer.label = spLabel || ttsLabel;
+            synthesizer.azureServiceEndpoint = "";
+            if (spAzureServiceEndpoint || azureServiceEndpoint) {
+                synthesizer.azureServiceEndpoint = spAzureServiceEndpoint || azureServiceEndpoint;
+            }
+            if (spModel || ttsModel) {
+                synthesizer.options = {
+                    model_id: spModel || ttsModel
+                };
+            }
+            return synthesizer;
+        }
+    }
+    buildRecognizer(sessionParams, stt, vad, azureConfig) {
+        var _a, _b, _c;
+        const { recognizer: sessionParamsRecognizer } = sessionParams || {};
+        const { vendor: spVendor, language: spLanguage, hints: spHints, label: spLabel, model: spModel, azureSttEndpointId: spAzureSttEndpointId, audioLogging: spAudioLogging, hintsBoost: spHintsBoost, punctuation: spPunctuation, altLanguages: spAltLanguages = [], deepgramOptions: spDeepgramOptions, vad: spVad } = sessionParamsRecognizer || {};
+        const { sttVendor, sttLanguage, sttHints, sttLabel, sttHintsBoost, sttDisablePunctuation, googleModel, deepgramEndpointing, deepgramEndpointingValue, sttDeepgramModel, deepgramSmartFormatting, deepgramShortUtterance, altLanguages = [] } = stt || {};
+        const recognizer = {};
+        recognizer.language = spLanguage || sttLanguage || undefined;
+        recognizer.hints = spHints || sttHints || undefined;
+        recognizer.label = spLabel || sttLabel || undefined;
+        recognizer.vendor = spVendor || sttVendor || undefined;
+        if (recognizer.hints) {
+            recognizer.hintsBoost = spHintsBoost || sttHintsBoost || 20;
+        }
+        recognizer.punctuation = spPunctuation || sttDisablePunctuation;
+        recognizer.azureSttEndpointId = spAzureSttEndpointId || (azureConfig === null || azureConfig === void 0 ? void 0 : azureConfig.azureSttContextId) || "";
+        recognizer.audioLogging = spAudioLogging || (azureConfig === null || azureConfig === void 0 ? void 0 : azureConfig.azureEnableAudioLogging);
+        if (recognizer.vendor) {
+            if (recognizer.vendor === "microsoft" || recognizer.vendor === "google") {
+                if (this.has(spAltLanguages)) {
+                    recognizer.altLanguages = spAltLanguages;
+                }
+                else if (this.has(altLanguages)) {
+                    recognizer.altLanguages = altLanguages;
+                }
+            }
+            const model = spModel || googleModel;
+            if (recognizer.vendor === "google" && model) {
+                recognizer.model = model;
+            }
+            if (recognizer.vendor === 'deepgram') {
+                const { model: spModel, endpointing: spEndpointing, shortUtterance: spShortUtterance, smartFormatting: spSmartFormatting, } = spDeepgramOptions || {};
+                /*
+                 * session params: 'endpointing' is a number
+                 * ssc node: 'deepgramEndpointing' => boolean, 'deepgramEndpointingValue' => number
+                 */
+                const isDeepgramEndpointingEnabled = (_a = (typeof spEndpointing === "number" || deepgramEndpointing)) !== null && _a !== void 0 ? _a : false;
+                recognizer.model = spModel || sttDeepgramModel;
+                const deepgramOptions = {
+                    endpointing: false,
+                    punctuate: recognizer.punctuation,
+                    shortUtterance: spShortUtterance || deepgramShortUtterance,
+                    model: recognizer.model,
+                    smartFormatting: (_b = (spSmartFormatting || deepgramSmartFormatting)) !== null && _b !== void 0 ? _b : false
+                };
+                if (isDeepgramEndpointingEnabled) {
+                    deepgramOptions.endpointing = (_c = (spEndpointing || deepgramEndpointingValue)) !== null && _c !== void 0 ? _c : 250;
+                }
+                recognizer.deepgramOptions = deepgramOptions;
+            }
+        }
+        if (this.has(spVad) || this.has(vad)) {
+            const { enable: spEnable, mode: spMode, voiceMs: spVoiceMs } = spVad || {};
+            const vadConfig = {
+                enable: spEnable || (vad === null || vad === void 0 ? void 0 : vad.enable)
+            };
+            const mode = Number(spMode) || (vad === null || vad === void 0 ? void 0 : vad.mode);
+            if (vadConfig.enable) {
+                /* mode must be a nuber between 0-3 - default is 1 */
+                if (mode < 0 || mode > 3 || isNaN(mode)) {
+                    vadConfig.mode = 1;
+                }
+                else {
+                    vadConfig.mode = mode;
+                }
+                vadConfig.voiceMs = spVoiceMs || (vad === null || vad === void 0 ? void 0 : vad.voiceMs);
+            }
+            recognizer.vad = vadConfig;
+        }
+        return recognizer;
+    }
+    buildFillerNoise(sessionParams, silenceOverlay) {
+        const { fillerNoise: sessionParamsFillerNoise } = sessionParams || {};
+        const { enable: spEnable, startDelaySecs: spStartDelaySecs, url: spUrl } = sessionParamsFillerNoise || {};
+        const { enable, startDelaySecs, url } = silenceOverlay || {};
+        if (!(this.has(sessionParamsFillerNoise) || this.has(silenceOverlay))) {
+            return;
+        }
+        const fillerNoise = {
+            enable: spEnable || enable,
+        };
+        if (fillerNoise.enable) {
+            fillerNoise.url = spUrl || url;
+            const startDelay = Number(spStartDelaySecs) || Number(startDelaySecs);
+            /* start delay secs mst be a value between 0 and 60. default: 0 */
+            if (startDelay < 0 || startDelay > 60 || isNaN(startDelaySecs)) {
+                fillerNoise.startDelaySecs = 0;
+            }
+            else {
+                fillerNoise.startDelaySecs = startDelay;
+            }
+        }
+        return fillerNoise;
+    }
+    disableTtsCache(sessionParams, tts) {
+        const { ttsDisableCache } = tts || {};
+        const { synthesizer } = sessionParams || {};
+        const { disableCache: spDisableCache } = synthesizer || {};
+        let disableTtsCache = false;
+        /* this will be applied to 'say' verb 'disableTtsCache'
+         *	say: {
+         *		text: "Hello World",
+         *		disableTtsCache: true
+         *	}
+         */
+        if (typeof spDisableCache === "boolean") {
+            disableTtsCache = spDisableCache;
+        }
+        else if (typeof ttsDisableCache === "boolean") {
+            disableTtsCache = ttsDisableCache;
+        }
+        return disableTtsCache;
+    }
+}
+const mapper = new SessionConfigMapper("voiceGateway2");
+export function voiceConfigParamsToVoiceSettings(config, api) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    let voiceSettings = {};
+    if (config.sttVendor === 'none') {
+        delete config.sttVendor;
+        delete config.sttLabel;
+    }
+    if (config.ttsVendor === 'none') {
+        delete config.ttsVendor;
+        delete config.ttsLabel;
+    }
+    if (typeof config.bargeInOnDtmf === 'boolean' || typeof config.bargeInOnSpeech === 'boolean') {
+        voiceSettings.bargeIn = {
+            bargeInEnable: false,
+            bargeInOnDtmf: (_a = config.bargeInOnDtmf) !== null && _a !== void 0 ? _a : false,
+            bargeInOnSpeech: (_b = config.bargeInOnSpeech) !== null && _b !== void 0 ? _b : false,
+            bargeInMinimumWords: config.bargeInMinWordCount,
+        };
+    }
+    // vad
+    voiceSettings.vad = {
+        enable: config.sttVadEnabled,
+        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];
+    }
+    const deepgramEndpointing = (_d = config.deepgramEndpointing) !== null && _d !== void 0 ? _d : true;
+    const deepgramShortUtterance = deepgramEndpointing ? false : true;
+    // stt (recognizer)
+    voiceSettings.stt = {
+        sttVendor: config.sttVendor,
+        sttLanguage: config.sttLanguage,
+        sttHints: hints,
+        sttLabel: (_e = config.sttLabel) !== null && _e !== void 0 ? _e : undefined,
+        sttDisablePunctuation: config.sttDisablePunctuation !== undefined &&
+            config.sttDisablePunctuation !== null
+            ? !config.sttDisablePunctuation
+            : undefined,
+        googleModel: (_f = config.googleModel) !== null && _f !== void 0 ? _f : undefined,
+        /* by default we enable endpointing - it is only undefined via SAP */
+        deepgramEndpointing,
+        deepgramEndpointingValue: (_g = config.deepgramEndpointingValue) !== null && _g !== void 0 ? _g : 250,
+        sttDeepgramModel: (_h = config.sttDeepgramModel) !== null && _h !== void 0 ? _h : "nova-2",
+        deepgramSmartFormatting: (_j = config.deepgramSmartFormatting) !== null && _j !== void 0 ? _j : undefined,
+        deepgramShortUtterance,
+    };
+    // tts (synthesizer)
+    voiceSettings.tts = {
+        ttsVendor: config.ttsVendor,
+        ttsLanguage: config.ttsLanguage,
+        ttsVoice: config.ttsVoice,
+        ttsDisableCache: config.ttsDisableCache,
+        ttsLabel: config.ttsLabel,
+    };
+    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);
+                }
+            });
+        }
+        else {
+            voiceSettings.stt.altLanguages = [];
+        }
+    }
+    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);
+                }
+            });
+        }
+        else {
+            voiceSettings.stt.altLanguages = [];
+        }
+    }
+    if (config.ttsVendor === "elevenlabs") {
+        voiceSettings.tts.ttsModel = config.ttsModel;
+    }
+    // userNoInput
+    voiceSettings.userNoInput = {
+        userNoInputMode: config.userNoInputMode,
+        userNoInputTimeout: config.userNoInputTimeout,
+        userNoInputRetries: config.userNoInputRetries,
+        userNoInputSpeech: config.userNoInputSpeech,
+        userNoInputUrl: config.userNoInputUrl,
+        userNoInputTimeoutEnable: config.userNoInputTimeoutEnable
+    };
+    voiceSettings.flowNoInput = {
+        flowNoInputMode: config.flowNoInputMode,
+        flowNoInputTimeout: config.flowNoInputTimeout,
+        flowNoInputRetries: config.flowNoInputRetries,
+        flowNoInputSpeech: config.flowNoInputSpeech,
+        flowNoInputUrl: config.flowNoInputUrl,
+        flowNoInputTimeoutEnable: config.flowNoInputTimeoutEnable,
+        flowNoInputFail: config.flowNoInputFail
+    };
+    // Check if userNoInputTimeout has a value and userNoInputTimeoutEnable is null or undefined to cover generic nodes
+    if (((_k = voiceSettings === null || voiceSettings === void 0 ? void 0 : voiceSettings.userNoInput) === null || _k === void 0 ? void 0 : _k.userNoInputTimeout) && (voiceSettings.userNoInput.userNoInputTimeoutEnable === null || voiceSettings.userNoInput.userNoInputTimeoutEnable === undefined)) {
+        voiceSettings.userNoInput.userNoInputTimeoutEnable = true;
+    }
+    voiceSettings.dtmf = {
+        dtmfEnable: config.dtmfEnable,
+        dtmfInterDigitTimeout: config.dtmfInterDigitTimeout,
+        dtmfMaxDigits: config.dtmfMaxDigits,
+        dtmfMinDigits: config.dtmfMinDigits,
+        dtmfSubmitDigit: (_l = config.dtmfSubmitDigit) === null || _l === void 0 ? void 0 : _l.trim(),
+    };
+    if (config === null || config === void 0 ? void 0 : config.dtmfEnable) {
+        if (voiceSettings.dtmf.dtmfSubmitDigit &&
+            !isValidDTMF(voiceSettings.dtmf.dtmfSubmitDigit)) {
+            if (api)
+                api.log("error", "Invalid DTMF Submit Digit");
+            delete voiceSettings.dtmf.dtmfSubmitDigit;
+        }
+        if (config === null || config === void 0 ? void 0 : config.dtmfEnable) {
+            if ((!config.dtmfInterDigitTimeout ||
+                typeof config.dtmfInterDigitTimeout !== "number") &&
+                (!config.dtmfMaxDigits || typeof config.dtmfMaxDigits !== "number") &&
+                (!config.dtmfSubmitDigit || config.dtmfSubmitDigit === ""))
+                voiceSettings.dtmf.dtmfInterDigitTimeout = 2000;
+        }
+    }
+    // continuousAsr
+    voiceSettings.continuousAsr = {
+        asrEnabled: config.asrEnabled,
+        asrDigit: config.asrDigit,
+        asrTimeout: config.asrTimeout,
+    };
+    if (config === null || config === void 0 ? void 0 : config.asrEnabled) {
+        if (config.asrDigit)
+            voiceSettings.continuousAsr.asrDigit = config.asrDigit.trim();
+        if (!config.asrTimeout || typeof config.asrTimeout !== "number")
+            voiceSettings.continuousAsr.asrTimeout = 3000;
+        if (voiceSettings.continuousAsr.asrDigit &&
+            !isValidDTMF(voiceSettings.continuousAsr.asrDigit)) {
+            if (api)
+                api.log("error", "Invalid DTMF Submit Digit");
+            delete voiceSettings.continuousAsr.asrDigit;
+        }
+    }
+    // Azure configurations
+    if ((config.sttVendor === "microsoft" && config.azureSttContextId)) {
+        voiceSettings.azureConfig = {
+            azureSttContextId: config.azureSttContextId
+                ? config.azureSttContextId.trim()
+                : undefined,
+            azureEnableAudioLogging: config.azureEnableAudioLogging || undefined
+        };
+    }
+    // atmosphere sounds
+    if (config.atmosphereAction) {
+        if ((_m = config.atmosphereUrl) === null || _m === void 0 ? void 0 : _m.length) {
+            if (!isValidUrl(config.atmosphereUrl)) {
+                throw new Error(`Audio file URL is invalid ${config.atmosphereUrl}`);
+            }
+        }
+        voiceSettings.atmosphereNoise = {
+            action: config.atmosphereAction,
+            url: config.atmosphereUrl || undefined,
+            volume: config.atmosphereVolume || undefined,
+            loop: config.atmosphereLoop || undefined
+        };
+    }
+    // silence overlay
+    if (typeof config.silenceOverlayAction === "boolean") {
+        voiceSettings.silenceOverlay = {
+            enable: config.silenceOverlayAction,
+            url: config.silenceOverlayURL || undefined,
+            startDelaySecs: config.silenceOverlayDelay || undefined
+        };
+    }
+    return stripNulls(voiceSettings);
+}
+export function vg2PayloadToActivityParams(payload) {
+    var _a, _b, _c, _d, _e;
+    const vg2Config = payload._voiceGateway2.json;
+    return stripNulls({
+        synthesizer: (_a = vg2Config.voiceGateway2Config) === null || _a === void 0 ? void 0 : _a.synthesizer,
+        recognizer: (_b = vg2Config.voiceGateway2Config) === null || _b === void 0 ? void 0 : _b.recognizer,
+        bargeIn: (_c = vg2Config.voiceGateway2Config) === null || _c === void 0 ? void 0 : _c.bargeIn,
+        user: (_d = vg2Config.cognigyConfig) === null || _d === void 0 ? void 0 : _d.user,
+        dtmf: (_e = vg2Config.cognigyConfig) === null || _e === void 0 ? void 0 : _e.dtmf,
+    });
+}
+export const setSessionConfig = {
+    handleInput(endpointType, voiceSettings) {
+        switch (endpointType) {
+            case "bandwidth":
+                return this.handleAudioCodesInput(voiceSettings, endpointType);
+            case "audioCodes":
+                return this.handleAudioCodesInput(voiceSettings, endpointType);
+            case "voiceGateway2":
+            default:
+                return this.handleVGInput(voiceSettings);
+        }
+    },
+    handleVGInput(voiceSettings, sessionParams, api) {
+        const { bargeIn, continuousAsr, stt, tts, userNoInput, dtmf, vad, azureConfig, atmosphereNoise, silenceOverlay, flowNoInput } = voiceSettings;
+        try {
+            const recognizer = mapper.buildRecognizer(sessionParams, stt, vad, azureConfig) || undefined;
+            mapper.recognizerApplyContinuousAsr(sessionParams, recognizer, continuousAsr);
+            // Check if there are configs for synthesizer, recognizer and bargeIn
+            const voiceConfig = {
+                synthesizer: mapper.buildSynthesizer(sessionParams, tts) || undefined,
+                recognizer,
+                bargeIn: mapper.buildBarge(sessionParams, dtmf, bargeIn) || undefined,
+                fillerNoise: mapper.buildFillerNoise(sessionParams, silenceOverlay) || undefined,
+            };
+            stripNulls(voiceConfig);
+            // Check if there are configs for No User Input and DTMF
+            const cognigyConfig = {
+                user: mapper.buildUser(sessionParams, userNoInput) || undefined,
+                flow: mapper.buildFlow(sessionParams, flowNoInput) || undefined,
+                dtmf: mapper.isDtmfEnabled(sessionParams, dtmf),
+                disableTtsCache: mapper.disableTtsCache(sessionParams, tts),
+            };
+            stripNulls(cognigyConfig);
+            const prePayload = {
+                cognigyConfig: Object.keys(cognigyConfig).length
+                    ? cognigyConfig
+                    : undefined,
+                voiceGateway2Config: Object.keys(voiceConfig).length
+                    ? voiceConfig
+                    : undefined,
+            };
+            if (atmosphereNoise) {
+                prePayload.voiceGateway2Atmosphere = stripNulls(atmosphereNoise);
+            }
+            if (prePayload.cognigyConfig === undefined) {
+                delete prePayload.cognigyConfig;
+            }
+            if (prePayload.voiceGateway2Config === undefined) {
+                delete prePayload.voiceGateway2Config;
+            }
+            const payload = {
+                _voiceGateway2: {
+                    json: Object.assign({}, prePayload),
+                },
+            };
+            return payload;
+        }
+        catch (error) {
+            console.error("Error in setSessionConfig.handleVGInput: ", error);
+        }
+    },
+    handleAudioCodesInput(voiceSettings, endpointType = "audioCodes") {
+        const { bargeIn, continuousAsr, stt, tts, userNoInput, dtmf, azureConfig } = voiceSettings;
+        const sessionParams = {};
+        if (stt) {
+            sessionParams.sttLanguage = stt.sttLanguage;
+            if (stt.sttHints && stt.sttHints.length > 0) {
+                const hints = [];
+                stt.sttHints.forEach((element) => {
+                    hints.push({ phrases: [element], boost: 20 });
+                });
+                sessionParams.sttSpeechContexts = hints;
+            }
+            sessionParams.sttDisablePunctuation = !stt.sttDisablePunctuation;
+            if (stt.googleModel) {
+                sessionParams.sttModel = stt.googleModel;
+            }
+        }
+        if (tts) {
+            sessionParams.ttsLanguage = tts.ttsLanguage;
+            sessionParams.voiceName = tts.ttsVoice;
+            if (tts.azureServiceEndpoint) {
+                sessionParams.ttsDeploymentId = tts.azureServiceEndpoint;
+            }
+            ;
+        }
+        if (dtmf) {
+            sessionParams.sendDTMF = dtmf.dtmfEnable;
+            sessionParams.dtmfCollect = dtmf.dtmfEnable;
+            if (sessionParams.dtmfCollect) {
+                if (dtmf.dtmfInterDigitTimeout && dtmf.dtmfInterDigitTimeout >= 0)
+                    sessionParams.dtmfCollectInterDigitTimeoutMS =
+                        dtmf.dtmfInterDigitTimeout;
+                sessionParams.dtmfCollectSubmitDigit = dtmf.dtmfSubmitDigit;
+                if (dtmf.dtmfMaxDigits && dtmf.dtmfMaxDigits > 0)
+                    sessionParams.dtmfCollectMaxDigits = dtmf.dtmfMaxDigits;
+            }
+        }
+        if (bargeIn) {
+            sessionParams.bargeIn = bargeIn.bargeInOnSpeech;
+            sessionParams.bargeInOnDTMF = bargeIn.bargeInOnDtmf;
+            if (bargeIn.bargeInMinimumWords >= 1 && bargeIn.bargeInMinimumWords <= 5) {
+                sessionParams.bargeInMinWordCount = bargeIn.bargeInMinimumWords || 1;
+            }
+            if (sessionParams.bargeInOnDTMF)
+                sessionParams.sendDTMF = true;
+        }
+        if (continuousAsr) {
+            sessionParams.continuousASR = continuousAsr.asrEnabled;
+            sessionParams.continuousASRDigits = continuousAsr.asrDigit;
+            sessionParams.continuousASRTimeoutInMS = continuousAsr.asrTimeout;
+        }
+        if (userNoInput) {
+            sessionParams.userNoInputRetries = userNoInput.userNoInputRetries || 0;
+            sessionParams.userNoInputTimeoutMS = userNoInput.userNoInputTimeout;
+            sessionParams.userNoInputAutoHangup = true;
+            sessionParams.userNoInputSendEvent = true;
+            if (userNoInput.userNoInputMode === "speech" &&
+                sessionParams.userNoInputRetries > 0)
+                sessionParams.userNoInputSpeech = userNoInput.userNoInputSpeech;
+            if (userNoInput.userNoInputMode === "play" &&
+                sessionParams.userNoInputRetries > 0)
+                sessionParams.userNoInputUrl = userNoInput.userNoInputUrl;
+        }
+        if (azureConfig === null || azureConfig === void 0 ? void 0 : azureConfig.azureSttContextId) {
+            sessionParams.sttContextId = azureConfig.azureSttContextId;
+            if (azureConfig.azureEnableAudioLogging) {
+                sessionParams.azureEnableAudioLogging =
+                    azureConfig.azureEnableAudioLogging;
+            }
+        }
+        const activities = {
+            type: "event",
+            name: "config",
+            sessionParams: sessionParams || {},
+        };
+        const contentKey = endpointType === "bandwidth" ? "_bandwidth" : "_voiceGateway";
+        const payload = {
+            [contentKey]: {
+                json: {
+                    activities: [activities],
+                },
+            },
+        };
+        return payload;
+    },
+};
+//# sourceMappingURL=setSessionConfig.mapper.js.map