@cognigy/rest-api-client 0.12.0 → 0.13.1

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

@@ -0,0 +1,296 @@
+"use strict";
+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) {
+    let voiceSettings = {};
+    if (config.bargeInOnSpeech || config.bargeInOnDtmf) {
+        voiceSettings.bargeIn = {
+            bargeInEnable: false,
+            bargeInOnDtmf: config.bargeInOnDtmf ? true : false,
+            bargeInOnSpeech: config.bargeInOnSpeech ? true : false,
+            bargeInMinimunWords: config.bargeInMinWordCount,
+        };
+    }
+    // vad
+    voiceSettings.vad = {
+        enable: config.sttVadEnabled,
+        mode: config.sttVadMode,
+        voiceMs: config.sttVadVoiceMs,
+    };
+    // stt (recognizer)
+    voiceSettings.stt = {
+        sttVendor: config.sttVendor,
+        sttLanguage: config.sttLanguage,
+        sttHints: config.sttHints,
+        sttDisablePunctuation: config.sttDisablePunctuation !== undefined &&
+            config.sttDisablePunctuation !== null
+            ? !config.sttDisablePunctuation
+            : undefined,
+    };
+    // tts (synthesizer)
+    voiceSettings.tts = {
+        ttsVendor: config.ttsVendor,
+        ttsLanguage: config.ttsLanguage,
+        ttsVoice: config.ttsVoice,
+    };
+    // userNoInput
+    voiceSettings.userNoInput = {
+        userNoInputMode: config.userNoInputMode,
+        userNoInputTimeout: config.userNoInputTimeout,
+        userNoInputRetries: config.userNoInputRetries,
+        userNoInputSpeech: config.userNoInputSpeech,
+        userNoInputUrl: config.userNoInputUrl,
+    };
+    // dtmf
+    voiceSettings.dtmf = {
+        dtmfEnable: config.dtmfEnable,
+        dtmfInterDigitTimeout: config.dtmfInterDigitTimeout,
+        dtmfMaxDigits: config.dtmfMaxDigits,
+        dtmfMinDigits: config.dtmfMinDigits,
+        dtmfSubmitDigit: config.dtmfSubmitDigit,
+    };
+    if (config === null || config === void 0 ? void 0 : config.dtmfEnable) {
+        if (config.dtmfSubmitDigit)
+            voiceSettings.dtmf.dtmfSubmitDigit = config.dtmfSubmitDigit.trim();
+        if (voiceSettings.dtmf.dtmfSubmitDigit &&
+            !(0, helper_1.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 &&
+            !(0, helper_1.isValidDTMF)(voiceSettings.continuousAsr.asrDigit)) {
+            if (api)
+                api.log("error", "Invalid DTMF Submit Digit");
+            delete voiceSettings.continuousAsr.asrDigit;
+        }
+    }
+    return (0, strip_nulls_1.stripNulls)(voiceSettings);
+}
+exports.voiceConfigParamsToVoiceSettings = voiceConfigParamsToVoiceSettings;
+function vg2PayloadToActivityParams(payload) {
+    var _a, _b, _c, _d, _e;
+    const vg2Config = payload._voiceGateway2.json;
+    return (0, strip_nulls_1.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,
+    });
+}
+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);
+        }
+    },
+    handleVGInput(voiceSettings) {
+        const { bargeIn, continuousAsr, stt, tts, userNoInput, dtmf, vad } = 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.punctuation = stt === null || stt === void 0 ? void 0 : stt.sttDisablePunctuation;
+        if (vad && vad.enable) {
+            recognizer.vad = {
+                enable: true,
+                mode: vad.mode,
+                voiceMs: vad.voiceMs,
+            };
+        }
+        //verify if there are TTS Configs to set
+        if (tts) {
+            synthesizer.vendor = tts.ttsVendor;
+            synthesizer.language = tts.ttsLanguage;
+            synthesizer.voice = tts.ttsVoice;
+        }
+        //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
+                : 10;
+        }
+        //verify if there are Continuous ASR Configs to set
+        if (continuousAsr === null || continuousAsr === void 0 ? void 0 : continuousAsr.asrEnabled) {
+            recognizer.asrDtmfTerminationDigit = continuousAsr.asrDigit;
+            recognizer.asrTimeout = continuousAsr.asrTimeout
+                ? continuousAsr.asrTimeout / 1000
+                : undefined;
+        }
+        //verify if there are Barge In Configs to set
+        if (bargeIn) {
+            barge.enable = bargeIn.bargeInEnable;
+            barge.minBargeinWordCount = bargeIn.bargeInMinimunWords;
+            barge.input = [];
+            barge.actionHook = "voice";
+            barge.dtmfBargein = bargeIn.bargeInOnDtmf;
+            if (barge.dtmfBargein) {
+                barge.enable = true;
+                barge.input.push("digits");
+            }
+            if (bargeIn.bargeInOnSpeech) {
+                barge.enable = true;
+                barge.input.push("speech");
+            }
+        }
+        //verify if there are DTMF Configs to set
+        if (dtmf) {
+            dtmfParam = dtmf.dtmfEnable;
+            if (dtmf.dtmfEnable) {
+                barge.interDigitTimeout =
+                    dtmf.dtmfInterDigitTimeout && dtmf.dtmfInterDigitTimeout >= 0
+                        ? dtmf.dtmfInterDigitTimeout === 0
+                            ? 0
+                            : dtmf.dtmfInterDigitTimeout / 1000
+                        : undefined;
+                barge.maxDigits =
+                    dtmf.dtmfMaxDigits && dtmf.dtmfMaxDigits >= 1
+                        ? dtmf.dtmfMaxDigits
+                        : undefined;
+                barge.minDigits = dtmf.dtmfMinDigits || 1;
+                barge.finishOnKey = dtmf.dtmfSubmitDigit;
+            }
+        }
+        //Check if there are configs for synthesizer, recognizer and bargeIn
+        const voiceConfig = {
+            synthesizer: synthesizer ? synthesizer : undefined,
+            recognizer: recognizer ? recognizer : undefined,
+            bargeIn: barge ? barge : undefined,
+        };
+        (0, strip_nulls_1.stripNulls)(voiceConfig);
+        //Check if there are configs for No User Input and DTMF
+        const cognigyConfig = {
+            user: user ? user : undefined,
+            dtmf: dtmfParam,
+        };
+        (0, strip_nulls_1.stripNulls)(cognigyConfig);
+        const prePayload = {
+            cognigyConfig: Object.keys(cognigyConfig).length
+                ? cognigyConfig
+                : undefined,
+            voiceGateway2Config: Object.keys(voiceConfig).length
+                ? voiceConfig
+                : undefined,
+        };
+        const payload = {
+            _voiceGateway2: {
+                json: (0, strip_nulls_1.stripNulls)(prePayload),
+            },
+        };
+        return payload;
+    },
+    handleAudioCodesInput(voiceSettings) {
+        const { bargeIn, continuousAsr, stt, tts, userNoInput, dtmf } = 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 (tts) {
+            sessionParams.ttsLanguage = tts.ttsLanguage;
+            sessionParams.voiceName = tts.ttsVoice;
+        }
+        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;
+            sessionParams.bargeInMinWordCount = bargeIn.bargeInMinimunWords;
+            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;
+        }
+        const activities = {
+            type: "event",
+            name: "config",
+            sessionParams: sessionParams || {},
+        };
+        const payload = {
+            _voiceGateway: {
+                json: {
+                    activities: [activities],
+                },
+            },
+        };
+        return payload;
+    },
+};
+//# sourceMappingURL=setSessionConfig.mapper.js.map

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transfer = void 0;
+const constants_1 = require("../utils/constants");
+exports.transfer = {
+    handleInput(endpointType, params, isGenericNode) {
+        try {
+            if (endpointType === constants_1.ENDPOINTS.AUDIO_CODES && isGenericNode && params.transferSipHeaders) {
+                const { transferReason, transferTarget, useTransferSipHeaders, transferSipHeaders } = params;
+                let headers = [];
+                for (const [key, value] of Object.entries(transferSipHeaders)) {
+                    const entry = { "name": key, "value": value };
+                    headers.push(entry);
+                }
+                ;
+                const target = transferTarget.includes("@")
+                    ? transferTarget
+                    : `tel:${transferTarget}`;
+                return this.handleAudioCodesInput({ transferReason, transferTarget: target, useTransferSipHeaders, transferSipHeaders: headers });
+            }
+            if (endpointType === constants_1.ENDPOINTS.VOICE_GATEWAY) {
+                return this.handleVGInput(params);
+            }
+            else if (endpointType === constants_1.ENDPOINTS.AUDIO_CODES) {
+                return this.handleAudioCodesInput(params);
+            }
+            else {
+                return this.handleVGInput(params);
+            }
+            ;
+        }
+        catch (error) {
+            throw Error(error.message);
+        }
+    },
+    handleVGInput(transferParam) {
+        const { transferTarget, useTransferSipHeaders, transferSipHeaders } = transferParam;
+        const payload = {
+            _voiceGateway2: {
+                json: {
+                    "sip:refer": {
+                        "referTo": transferTarget,
+                        "actionHook": 'refer'
+                    }
+                }
+            }
+        };
+        if (useTransferSipHeaders && typeof transferSipHeaders === "object") {
+            payload._voiceGateway2.json["sip:refer"]["headers"] = transferSipHeaders;
+        }
+        return payload;
+    },
+    handleAudioCodesInput(transferParam) {
+        const { transferReason, transferTarget, useTransferSipHeaders, transferSipHeaders, transferNotifications, transferNotificationsHangupMS, transferReferredByURL } = transferParam;
+        const activities = {
+            "type": "event",
+            "name": "transfer",
+            "activityParams": {
+                "transferTarget": transferTarget,
+                "handoverReason": transferReason,
+            }
+        };
+        if (transferReferredByURL) {
+            activities.activityParams["transferReferredByURL"] = transferReferredByURL;
+        }
+        ;
+        if (useTransferSipHeaders) {
+            activities.activityParams["transferSipHeaders"] = transferSipHeaders;
+        }
+        ;
+        if (transferNotifications) {
+            activities.activityParams["transferNotifications"] = transferNotifications;
+            activities.activityParams["transferNotificationsHangupMS"] = transferNotificationsHangupMS;
+        }
+        ;
+        const payload = {
+            _voiceGateway: {
+                json: {
+                    activities: [activities]
+                }
+            }
+        };
+        return payload;
+    }
+};
+//# sourceMappingURL=transfer.mapper.js.map

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BARGE_IN = void 0;
+/** Custom Modules */
+const createNodeDescriptor_1 = require("../../../createNodeDescriptor");
+/** Helper Modules */
+const setSessionConfig_mapper_1 = require("../mappers/setSessionConfig.mapper");
+const design_1 = require("../utils/design");
+const setSessionConfig_mapper_2 = require("../mappers/setSessionConfig.mapper");
+exports.BARGE_IN = (0, createNodeDescriptor_1.createNodeDescriptor)({
+    type: "bargeIn",
+    defaultLabel: "Barge In - Config",
+    tags: ["voice"],
+    appearance: {
+        color: design_1.nodeColor,
+    },
+    summary: "Enables Barge In for the entire call session",
+    fields: [
+        {
+            key: "bargeInOnSpeech",
+            type: "toggle",
+            label: "Barge In On Speech",
+            description: "Allows the user to interrupt bot output with speech",
+            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.",
+            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",
+            defaultValue: 1,
+            params: {
+                min: 1,
+                max: 5,
+                step: 1,
+            },
+        },
+    ],
+    function: async ({ cognigy, config }) => {
+        const { api, input } = cognigy;
+        const { endpointType } = input;
+        try {
+            const payload = setSessionConfig_mapper_1.setSessionConfig.handleInput(endpointType, (0, setSessionConfig_mapper_2.voiceConfigParamsToVoiceSettings)(config, api));
+            api.say(null, {
+                _cognigy: payload,
+            });
+        }
+        catch (error) {
+            throw new Error(`Error on Barge In node. Error message: ${error.message}`);
+        }
+    },
+});
+//# sourceMappingURL=bargeIn.js.map

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTINUOUS_ASR = void 0;
+/** Custom Modules */
+const createNodeDescriptor_1 = require("../../../createNodeDescriptor");
+/** Helper Modules */
+const setSessionConfig_mapper_1 = require("../mappers/setSessionConfig.mapper");
+const design_1 = require("../utils/design");
+const setSessionConfig_mapper_2 = require("../mappers/setSessionConfig.mapper");
+exports.CONTINUOUS_ASR = (0, createNodeDescriptor_1.createNodeDescriptor)({
+    type: "continuousASR",
+    defaultLabel: "Continuous ASR - Config",
+    tags: ["voice"],
+    appearance: {
+        color: design_1.nodeColor,
+    },
+    summary: "Enables Continuous ASR for the entire call session",
+    fields: [
+        {
+            key: "asrEnabled",
+            type: "toggle",
+            label: "Enable Continuous ASR",
+            description: "Enable Continuous ASR",
+            defaultValue: false,
+        },
+        {
+            key: "asrDigit",
+            type: "cognigyText",
+            label: "Continuous ASR Submit Digit",
+            description: "Defines a special DTMF key, which sends the accumulated recognitions to the flow",
+            defaultValue: "#",
+            condition: {
+                key: "asrEnabled",
+                value: true,
+            },
+            params: {
+                type: "string",
+                minLength: 1,
+                maxLength: 1,
+            },
+        },
+        {
+            key: "asrTimeout",
+            type: "number",
+            label: "Continuous ASR Timeout",
+            description: "Defines the number of milliseconds of silence before the accumulated recognitions are send to the flow",
+            defaultValue: 3000,
+            condition: {
+                key: "asrEnabled",
+                value: true,
+            },
+            params: {
+                min: 500,
+                max: 60000,
+            },
+        },
+    ],
+    function: async ({ cognigy, config }) => {
+        const { api, input } = cognigy;
+        const { endpointType } = input;
+        try {
+            const payload = setSessionConfig_mapper_1.setSessionConfig.handleInput(endpointType, (0, setSessionConfig_mapper_2.voiceConfigParamsToVoiceSettings)(config, api));
+            api.say(null, {
+                _cognigy: payload,
+            });
+        }
+        catch (error) {
+            throw new Error(`Error on Continuous ASR node. Error message: ${error.message}`);
+        }
+    },
+});
+//# sourceMappingURL=continuousAsr.js.map

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DTMF = void 0;
+/** Custom Modules */
+const createNodeDescriptor_1 = require("../../../createNodeDescriptor");
+/** Helper Modules */
+const setSessionConfig_mapper_1 = require("../mappers/setSessionConfig.mapper");
+const design_1 = require("../utils/design");
+const setSessionConfig_mapper_2 = require("../mappers/setSessionConfig.mapper");
+exports.DTMF = (0, createNodeDescriptor_1.createNodeDescriptor)({
+    type: "dtmf",
+    defaultLabel: "DTMF Collect - Config",
+    tags: ["voice"],
+    appearance: {
+        color: design_1.nodeColor,
+    },
+    summary: "Enables capturing of DTMF signals by the bot during the entire call session",
+    fields: [
+        {
+            key: "dtmfEnable",
+            type: "toggle",
+            label: "Capture DTMF signals",
+            description: "Enables capturing of DTMF signals by the bot",
+            defaultValue: false,
+        },
+        {
+            key: "dtmfInterDigitTimeout",
+            type: "number",
+            label: "DTMF Inter Digit Timeout",
+            description: "Defines the timeout in between collected DTMF digits",
+            defaultValue: 2000,
+            condition: {
+                key: "dtmfEnable",
+                value: true,
+            },
+            params: {
+                min: 0,
+            },
+        },
+        {
+            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",
+            defaultValue: 1,
+            condition: {
+                key: "dtmfEnable",
+                value: true,
+            },
+            params: {
+                min: 1,
+            },
+        },
+        {
+            key: "dtmfSubmitDigit",
+            type: "cognigyText",
+            label: "DTMF Submit Digit",
+            description: "Defines the DTMF submit digit which will be used for submitting the previously entered digits.",
+            defaultValue: "#",
+            condition: {
+                key: "dtmfEnable",
+                value: true,
+            },
+        },
+    ],
+    function: async ({ cognigy, config }) => {
+        const { api, input } = cognigy;
+        const { endpointType } = input;
+        const dtmfConfig = {
+            dtmfEnable: config.dtmfEnable,
+            dtmfInterDigitTimeout: config.dtmfInterDigitTimeout,
+            dtmfMaxDigits: config.dtmfMaxDigits,
+            dtmfSubmitDigit: config.dtmfSubmitDigit
+        };
+        try {
+            const payload = setSessionConfig_mapper_1.setSessionConfig.handleInput(endpointType, (0, setSessionConfig_mapper_2.voiceConfigParamsToVoiceSettings)(dtmfConfig, api));
+            api.say(null, {
+                _cognigy: payload,
+            });
+        }
+        catch (error) {
+            throw new Error(`Error on DTMF node. Error message: ${error.message}`);
+        }
+    },
+});
+//# sourceMappingURL=dtmf.js.map

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HANG_UP = void 0;
+/** Custom Modules */
+const createNodeDescriptor_1 = require("../../../createNodeDescriptor");
+/** Helper Modules */
+const hangup_mapper_1 = require("../mappers/hangup.mapper");
+const design_1 = require("../utils/design");
+exports.HANG_UP = (0, createNodeDescriptor_1.createNodeDescriptor)({
+    type: "hangup",
+    defaultLabel: "Hang Up",
+    tags: ['voice'],
+    preview: {
+        key: "hangupReason",
+        type: "text"
+    },
+    appearance: {
+        color: design_1.nodeColor
+    },
+    summary: "Hangs up the call",
+    fields: [
+        {
+            key: "hangupReason",
+            label: "Reason for hang up",
+            type: "cognigyText",
+            defaultValue: "Bot ended the call",
+            params: {
+                required: true
+            }
+        }
+    ],
+    function: async ({ cognigy, config }) => {
+        const { api, input } = cognigy;
+        const { hangupReason } = config;
+        const { endpointType } = input;
+        try {
+            const payload = hangup_mapper_1.hangUp.handleInput(endpointType, hangupReason);
+            api.say(null, {
+                _cognigy: payload
+            });
+        }
+        catch (error) {
+            throw new Error(`Error on hangup node. Error message: ${error.message}`);
+        }
+        ;
+    }
+});
+//# sourceMappingURL=hangup.js.map