@cognigy/rest-api-client 0.14.0 → 0.15.0

package/build/shared/helper/nlu/textCleaner.js

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTextCleaner = exports.TextCleaner = void 0;
+const dicts_1 = require("./dicts/dicts");
+;
+/**
+ * A class to clean up text
+ * Mainly written to deal with text coming in from STT
+ */
+class TextCleaner {
+    /**
+     * Creates an instance of CleanText
+     * @param locale The locale to use (e.g. "de")
+     * @param additionalAllowedCharacters Extra allowed symbols for this instance (e.g. ["-", "*"])
+     * @param additionalMappedSymbols Extra allowed symbol words for this instance (e.g. {"minus": "-"})
+     * @param additionalSpecialPhrases Special words which may need replacing (e.g. if you want to detect cities, you might want to replace "färben" with "verden")
+     * @param additionalPhoneticAlphabet Extra spelling alphabet for this instance (e.g. {"alfa": "a", "bravo": "b"})
+     */
+    constructor(locale, additionalAllowedCharacters = [], additionalMappedSymbols = {}, additionalSpecialPhrases = {}, additionalPhoneticAlphabet = null) {
+        this.locale = locale;
+        this.allowedCharacters = dicts_1.LOCALE_SPECIFIC_SYMBOLS[locale].concat(additionalAllowedCharacters);
+        if (additionalPhoneticAlphabet === null) {
+            additionalPhoneticAlphabet = dicts_1.EXTRA_SPELLING_ALPHABET[locale];
+        }
+        this.dictAlphabet = dicts_1.ALPHABET[locale];
+        this.dictAlphabet = Object.assign(Object.assign({}, this.dictAlphabet), additionalPhoneticAlphabet);
+        this.dictSymbolWords = dicts_1.SYMBOL_WORDS[locale];
+        this.dictSymbolWords = Object.assign(Object.assign({}, this.dictSymbolWords), additionalMappedSymbols);
+        this.dictSpecials = Object.assign({}, additionalSpecialPhrases);
+        this.dictPunctuation = dicts_1.PUNCTUATION;
+        this.listExcludedWords = dicts_1.EXCLUDE[locale];
+        this.dictNumbers = dicts_1.NUMBERS_DICT[locale];
+        this.dictNumberRepeaters = dicts_1.NUMBERS_REPEAT[locale];
+        this.dictNumberMultipliers = dicts_1.NUMBERS_MULTIPLIERS[locale];
+        this.dictPhoneticConnectors = dicts_1.PHONETIC_CONNECTORS[locale];
+        if (this.dictPhoneticConnectors.length > 0) {
+            // sort in descending order for the regex to work properly
+            this.dictPhoneticConnectors.sort((a, b) => b.length - a.length);
+        }
+        // create the regex of allowed characters.
+        // the .replace portion escapes the additional allowed symbols so they can be used in the regex
+        this.allowedSymbolsRegex = new RegExp(`[^A-Za-z0-9${this.allowedCharacters.join("").replace(/[-.*+?^${}()|[\]\\]/g, '\\$&')}\\s]+`, "g");
+    }
+    /**
+     * Function to executed all or selected functions of this class on a phrase
+     * @param phrase The phrase to clean
+     * @param options Optional toggle for cleaning functions
+     * @returns The cleaned phrase
+     */
+    cleanAll(phrase, options, detailedSlots) {
+        if (!options || options.cleanDisallowedSymbols)
+            phrase = this.cleanDisallowedSymbols(phrase);
+        if (!options || options.resolveSpelledOutNumbers)
+            phrase = this.resolveSpelledOutNumbers(phrase, detailedSlots, false);
+        if (!options || options.resolvePhoneticAlphabet)
+            phrase = this.resolvePhoneticAlphabet(phrase);
+        if (!options || options.replaceSpecialWords)
+            phrase = this.replaceSpecialWords(phrase);
+        if (!options || options.resolveSpelledOutAlphabet)
+            phrase = this.resolveSpelledOutAlphabet(phrase);
+        if (!options || options.resolvePhoneticCounters)
+            phrase = this.resolvePhoneticCounters(phrase);
+        if (!options || options.contractSingleCharacters)
+            phrase = this.contractSingleCharacters(phrase);
+        if (!options || options.contractNumberGroups)
+            phrase = this.contractNumberGroups(phrase);
+        if (!options || options.trimResult)
+            phrase = this.trimResult(phrase);
+        return phrase;
+    }
+    /**
+     * Remove all symbols which are not allowed
+     */
+    cleanDisallowedSymbols(phrase) {
+        phrase = phrase.toLowerCase().replace(this.allowedSymbolsRegex, '');
+        phrase = phrase.replace(/\s+/g, ' ');
+        const words = phrase.split(' ');
+        const cleanedWords = words.map((word) => {
+            var _a, _b;
+            // figure out if last character is a full stop
+            const lastChar = word.slice(-1);
+            const hasPunctuation = this.dictPunctuation.indexOf(lastChar) !== -1;
+            let replacement = word;
+            if (hasPunctuation) {
+                word = word.slice(0, -1);
+                replacement = ((_a = this.dictSymbolWords[word]) !== null && _a !== void 0 ? _a : word) + lastChar;
+            }
+            else {
+                replacement = (_b = this.dictSymbolWords[word]) !== null && _b !== void 0 ? _b : word;
+            }
+            // if word was found in the dictionary, add it to the list of additional allowed characters
+            if (this.dictSymbolWords[word] && this.allowedCharacters.indexOf(this.dictSymbolWords[word]) === -1) {
+                this.allowedCharacters.push(this.dictSymbolWords[word]);
+                this.allowedSymbolsRegex = new RegExp(`[^A-Za-z0-9${this.allowedCharacters.join("").replace(/[-.*+?^${}()|[\]\\]/g, '\\$&')}\\s]+`, "g");
+            }
+            return replacement;
+        });
+        phrase = cleanedWords.join(' ');
+        return phrase;
+    }
+    /**
+     * Replaces all number words with their numerical representation
+     * e.g. "eins zwei drei" -> "1 2 3"
+     * @param preserveExcludedWords If true, words which are in the listExcludedWords will not be replaced
+     */
+    resolveSpelledOutNumbers(phrase, detailedSlots, preserveExcludedWords) {
+        // check if we have a detailedSlots NUMBER object
+        if (detailedSlots && detailedSlots.NUMBER && Array.isArray(detailedSlots.NUMBER) && detailedSlots.NUMBER.length > 0) {
+            detailedSlots.NUMBER.forEach((num) => {
+                // special rule for de-DE, as our NLU captures "mal" as part of the number words
+                // if we replace this, we can't resolve phonetic counters anymore
+                // in addition the German NLU parser finds IPv4 addresses with full length (123.123.123.132) as numbers, which we don't want to replace
+                if (this.locale !== "de" || (!num.text.includes("mal") && !num.text.match(/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/))) {
+                    phrase = phrase.replace(num.text, num.data.value.toString());
+                }
+            });
+        }
+        phrase = phrase.toLowerCase().split(' ')
+            .filter((i) => preserveExcludedWords || !this.listExcludedWords.includes(i))
+            .map((w, i, splits) => {
+            if (this.dictNumbers[w] !== undefined) {
+                if (splits[i + 1] && this.dictNumbers[w + " " + splits[i + 1]] !== undefined) {
+                    const result = this.dictNumbers[w + " " + splits[i + 1]];
+                    delete splits[i + 1];
+                    return result;
+                }
+                else {
+                    return this.dictNumbers[w];
+                }
+            }
+            else
+                return w;
+        }).join(' ').replace(/\s\s/g, ' ');
+        return phrase;
+    }
+    /**
+     * Replaces specifically determined words with their replacements
+     * e.g. "färben" -> "verden"
+     */
+    replaceSpecialWords(phrase) {
+        phrase = phrase.toLowerCase().replace(this.allowedSymbolsRegex, '');
+        phrase = phrase.replace(/\s+/g, ' ');
+        const words = phrase.split(' ');
+        const cleanedWords = words.map((word) => {
+            var _a, _b;
+            // figure out if last character is a punctuation symbol
+            const lastChar = word.slice(-1);
+            const hasPunctuation = this.dictPunctuation.indexOf(lastChar) !== -1;
+            let replacement = word;
+            if (hasPunctuation) {
+                word = word.slice(0, -1);
+                replacement = ((_a = this.dictSpecials[word]) !== null && _a !== void 0 ? _a : word) + lastChar;
+            }
+            else {
+                replacement = (_b = this.dictSpecials[word]) !== null && _b !== void 0 ? _b : word;
+            }
+            return replacement;
+        });
+        phrase = cleanedWords.join(' ');
+        return phrase;
+    }
+    /**
+     * Detects and replaces all words which are known in the spelling alphabet
+     * e.g. "alpha tango lima" -> "a t l" or "anton ida otto" -> "a i o"
+     */
+    resolvePhoneticAlphabet(phrase) {
+        phrase = phrase.toLowerCase().replace(this.allowedSymbolsRegex, '');
+        phrase = phrase.replace(/\s+/g, ' ');
+        const words = phrase.split(' ');
+        const cleanedWords = words.map((word) => {
+            var _a;
+            let lastChar = word.slice(-1);
+            if (this.dictPunctuation.indexOf(lastChar) !== -1) {
+                // remove punctuation
+                word = word.slice(0, -1);
+            }
+            else
+                lastChar = "";
+            const replacement = (_a = this.dictAlphabet[word]) !== null && _a !== void 0 ? _a : word;
+            return replacement + lastChar;
+        });
+        phrase = cleanedWords.join(' ');
+        return phrase;
+    }
+    /**
+     * Resolves string like "a for anton b for bertram" to "a b"
+     */
+    resolveSpelledOutAlphabet(phrase) {
+        phrase = phrase.toLowerCase();
+        while (true) {
+            const regex = new RegExp(`(\\s|^)([a-z]{1,3}) (${this.dictPhoneticConnectors.join("|")}) \\w+`, "i");
+            const match = phrase.match(regex);
+            if (match) {
+                const start = match.index;
+                const stop = start + match[0].length;
+                const letter = this._validateReduce(phrase, match[2], start, stop, match[3]);
+                phrase = phrase.slice(0, start) + ' ' + letter + phrase.slice(stop);
+            }
+            else {
+                break;
+            }
+        }
+        // Replace letter multiplication
+        for (const repeat in this.dictNumbers) {
+            while (true) {
+                const match = phrase.match(new RegExp(`(${repeat} [a-z]\\b)`));
+                if (match) {
+                    const start = match.index;
+                    const stop = start + match[0].length;
+                    const letter = this.dictNumbers[repeat].repeat(Number(phrase.slice(start, stop).slice(-1)));
+                    phrase = phrase.slice(0, start) + letter + phrase.slice(stop);
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        return phrase;
+    }
+    /**
+     * Resolves strings like "three times 2" to "222" or "double 4" to "44"
+     * Only takes the last number of the counter and first of the repeater
+     * e.g. ("352 mal 355" becomes "2 mal 3" > "333")
+     */
+    resolvePhoneticCounters(phrase) {
+        phrase = phrase.toLowerCase();
+        // first we check for "X times Y"-style counters
+        let matches;
+        do {
+            const allowedRepeaters = this.dictNumberMultipliers.join("|");
+            const xMalYRegex = new RegExp(`(\\d){1}\\s*(${allowedRepeaters}|\\*)\\s*[die\\s]*(\\d+|\\w+)`, "gi");
+            phrase = phrase.replace(/\s\s/gi, ' ');
+            matches = xMalYRegex.exec(phrase);
+            if (matches && !isNaN(Number(matches[1])) && !isNaN(Number(matches[3]))) {
+                // string is like "3 mal 4"
+                const counter = Number(matches[1]);
+                let replacer = "";
+                let remainer = "";
+                let adder = matches[3];
+                if (adder.length > 1 && !isNaN(Number(adder)) && Number(adder) > 12) {
+                    // if number is > 12, we assume that the user meant to write "3 times 1 and 3" instead of "3 times 13"
+                    // otherwise we assume "2 times 11" means "1111"
+                    remainer = adder.substring(1, adder.length);
+                    adder = adder.substring(0, 1);
+                }
+                for (let i = 0; i < counter; i++) {
+                    replacer += adder;
+                }
+                phrase = phrase.replace(matches[0].replace(remainer, ""), replacer);
+            }
+            else if (matches && !isNaN(Number(matches[1])) && isNaN(Number(matches[3]))) {
+                // string is like "3 mal x"
+                const counter = Number(matches[1]);
+                let replacer = "";
+                let remainer = "";
+                let adder = matches[3];
+                // this happens if adder is a string and starts with a number
+                if (adder.length > 1 && !isNaN(Number(adder.substring(0, 1)))) {
+                    remainer = adder.substring(1, adder.length);
+                    adder = adder.substring(0, 1);
+                }
+                // the next checks happen only if the adder is a string
+                if (isNaN(Number(adder)) && typeof adder === "string" && adder.length > 1 && dicts_1.ALPHABET.de[adder]) {
+                    // adder is part of the spelling alphabet (e.g. "alpha"), so we use the corresponding letter
+                    adder = dicts_1.ALPHABET.de[matches[3]];
+                }
+                else if (isNaN(Number(adder)) && typeof adder === "string" && adder.length > 1 && !dicts_1.ALPHABET.de[adder]) {
+                    // adder is NOT part of the spelling alphabet (e.g. "alpha"), so we use the first letter only
+                    remainer = adder.substring(1, adder.length);
+                    adder = adder.substring(0, 1);
+                }
+                for (let i = 0; i < counter; i++) {
+                    replacer += adder;
+                }
+                phrase = phrase.replace(matches[0].replace(remainer, ""), replacer);
+            }
+        } while (matches);
+        // here we check for "double X"-style counters
+        let matches2;
+        do {
+            const allowedRepeaters = Object.keys(this.dictNumberRepeaters).join("|");
+            const reg2 = new RegExp(`(${allowedRepeaters})\\s*?[die\\s]*(\\d+|\\w+)`, "gi");
+            matches2 = reg2.exec(phrase);
+            if (matches2 && this.dictNumberRepeaters[matches2[1]]) {
+                const counter = Number(this.dictNumberRepeaters[matches2[1]]);
+                let replacer = "";
+                let remainer = "";
+                let adder = matches2[2];
+                if (adder.length > 1 && !isNaN(Number(adder)) && Number(adder) > 12) {
+                    // if number is > 12, we assume that the user meant to write "double 1 and 3" instead of "double 13"
+                    // otherwise we assume "double 11" means "1111"
+                    remainer = adder.substring(1, adder.length);
+                    adder = adder.substring(0, 1);
+                }
+                if (isNaN(Number(adder)) && typeof adder === "string" && adder.length > 1 && dicts_1.ALPHABET.de[adder]) {
+                    // adder is part of the spelling alphabet (e.g. "alpha"), so we use the corresponding letter
+                    adder = dicts_1.ALPHABET.de[matches2[2]];
+                }
+                else if (isNaN(Number(adder)) && typeof adder === "string" && adder.length > 1 && !dicts_1.ALPHABET.de[adder]) {
+                    // adder is NOT part of the spelling alphabet (e.g. "alpha"), so we use the first letter only
+                    remainer = adder.substring(1, adder.length);
+                    adder = adder.substring(0, 1);
+                }
+                for (let i = 0; i < counter; i++) {
+                    replacer += adder;
+                }
+                phrase = phrase.replace(matches2[0].replace(remainer, ""), replacer);
+            }
+        } while (matches2);
+        return phrase;
+    }
+    /**
+     * Joins all single characters standing alone into a full string
+     * e.g. "my name is h e l t e w i g" > "my name is heltewig"
+     */
+    contractSingleCharacters(phrase) {
+        const words = phrase.split(' ');
+        const result = [];
+        for (let i = 0; i < words.length; i++) {
+            const word = words[i];
+            // we check whether the word is either a single character or a single character followed by a punctuation mark
+            // if so, we check whether the previous word is a single character and if yes, we join them
+            if ((word.length === 1 || (word.length === 2 && [".", ",", "!", "?"].indexOf(word[1]) > -1)) && i > 0 && words[i - 1].length === 1) {
+                result[result.length - 1] += word;
+            }
+            else {
+                result.push(word);
+            }
+        }
+        // Join the words back together with spaces
+        return result.join(' ');
+    }
+    /**
+     * Joins all numbers standing next to each other
+     * e.g. "his number is 333 43 22 44" > "his number is 333432244"
+     */
+    contractNumberGroups(phrase) {
+        // Use a regular expression to match all the number groups in the input string
+        const numberGroups = phrase.match(/(\d[\d\s]*\d|\d)/g);
+        if (!numberGroups) {
+            // If there are no number groups, return the original phrase
+            return phrase;
+        }
+        // Join the number groups, removing spaces in between
+        const contractedNumberGroups = numberGroups.map(group => group.replace(/\s+/g, ''));
+        // Replace the original number groups with the contracted ones
+        let result = phrase;
+        for (let i = 0; i < numberGroups.length; i++) {
+            result = result.replace(numberGroups[i], contractedNumberGroups[i]);
+        }
+        return result;
+    }
+    /**
+     * Trims the start and end of the string and replaces double spaces with single spaces
+     */
+    trimResult(phrase) {
+        phrase = phrase.trim();
+        phrase = phrase.replace(/\s+/g, ' ');
+        return phrase;
+    }
+    /**
+     * Helper function for resolveSpelledOutAlphabet
+     * @param phrase The phrase to resolve
+     * @param letter The letter found in LETTER as in THIRDWORD
+     * @param start The start index of the detected partial phrase
+     * @param stop The stop index of the detected partial phrase
+     * @param separator The separator (e.g. "as in" or "wie")
+     * @returns string
+     */
+    _validateReduce(phrase, letter, start, stop, separator) {
+        if (letter.length === 1) {
+            const thirdWord = phrase
+                .substring(start, stop)
+                .trim()
+                .split(` ${separator} `)[1];
+            if (letter !== thirdWord[0]) {
+                letter = thirdWord[0];
+            }
+        }
+        return letter;
+    }
+}
+exports.TextCleaner = TextCleaner;
+/**
+ * Returns a new instance of TextCleaner
+ */
+function getTextCleaner(locale, options) {
+    return new TextCleaner(locale, options === null || options === void 0 ? void 0 : options.additionalAllowedCharacters, options === null || options === void 0 ? void 0 : options.additionalMappedSymbols, options === null || options === void 0 ? void 0 : options.additionalSpecialPhrases, options === null || options === void 0 ? void 0 : options.additionalPhoneticAlphabet);
+}
+exports.getTextCleaner = getTextCleaner;
+//# sourceMappingURL=textCleaner.js.map

package/build/shared/interfaces/IApiKey.js

@@ -1,14 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.apiKeyQuerySchema = exports.apiKeySchema = exports.generateApiKeyRedisKeys = void 0;
+exports.apiKeyQuerySchema = exports.apiKeySchema = void 0;
 /* Custom Modules */
 const createQuerySchema_1 = require("../helper/createQuerySchema");
-const generateApiKeyRedisKeys = (data) => {
-    return [
-        `apiKey:${data.apiKey}`,
-    ];
-};
-exports.generateApiKeyRedisKeys = generateApiKeyRedisKeys;
 exports.apiKeySchema = {
     title: "apiKeyDataSchema",
     type: "object",
@@ -22,6 +16,7 @@ exports.apiKeySchema = {
         userReference: { type: "string", format: "mongo-id" },
         ttl: { type: "integer", maximum: 3 * 365 * 24 * 60 * 60 * 1000, minimum: 0 },
         expiresAt: { type: "object" },
+        schemaVersion: { type: "integer", minimum: 1 },
     }
 };
 exports.apiKeyQuerySchema = (0, createQuerySchema_1.createQuerySchema)("apiKeyQuerySchema", exports.apiKeySchema);

package/build/shared/interfaces/IOrganisation.js

@@ -1,14 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.organisationQuerySchema = exports.organisationSchema = exports.organisationDataSchema = exports.organisationPasswordPolicySchema = exports.organisationDataPrivacySettingsSchema = exports.generateOrganisationRedisKeys = void 0;
+exports.organisationQuerySchema = exports.organisationSchema = exports.organisationDataSchema = exports.organisationPasswordPolicySchema = exports.organisationDataPrivacySettingsSchema = void 0;
 /* Custom Modules */
 const createQuerySchema_1 = require("../helper/createQuerySchema");
-const generateOrganisationRedisKeys = (data) => {
-    return [
-        `organisationId:${data.organisationId}`,
-    ];
-};
-exports.generateOrganisationRedisKeys = generateOrganisationRedisKeys;
 exports.organisationDataPrivacySettingsSchema = {
     title: "organisationDataPrivacySettingsSchema",
     type: "object",
@@ -18,6 +12,7 @@ exports.organisationDataPrivacySettingsSchema = {
         useAnalytics: { type: "boolean" },
         useContactProfiles: { type: "boolean" },
         useConversations: { type: "boolean" },
+        maskIPAddress: { type: "boolean" },
         maskAnalytics: { type: "boolean" },
         maskLogging: { type: "boolean" },
         ignoreList: { type: "array", items: { type: "string" }, additionalItems: false, minItems: 0 }

package/build/shared/interfaces/IProfileSchema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateProfileSchemaRedisKeys = exports.defaultProfile = exports.profileSchemaSchema = exports.profileSchemaEntry = exports.profileEntrySchemaTypes = void 0;
+exports.defaultProfile = exports.profileSchemaSchema = exports.profileSchemaEntry = exports.profileEntrySchemaTypes = void 0;
 const IEntityMeta_1 = require("./resources/IEntityMeta");
 exports.profileEntrySchemaTypes = ["string", "object", "number", "boolean"];
 exports.profileSchemaEntry = {
@@ -37,10 +37,4 @@ exports.defaultProfile = {
     accepted_gdpr: false,
     goals: [],
 };
-const generateProfileSchemaRedisKeys = (data) => {
-    return [
-        `organisationId:${data.organisationId}:projectId:${data.projectId}:profileSchema`,
-    ];
-};
-exports.generateProfileSchemaRedisKeys = generateProfileSchemaRedisKeys;
 //# sourceMappingURL=IProfileSchema.js.map

package/build/shared/interfaces/agentAssist/ISendTileUpdateParams.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ISendTileUpdateParams.js.map

package/build/shared/interfaces/agentAssist/ISendTileUpdateReferenceParams.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ISendTileUpdateReferenceParams.js.map

package/build/shared/interfaces/agentAssist/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/build/shared/interfaces/ai.js

@@ -1,19 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AzureOpenAiModels = exports.OpenAiModels = void 0;
-var OpenAiModels;
-(function (OpenAiModels) {
-    OpenAiModels["davinci"] = "text-davinci-003";
-    OpenAiModels["curie"] = "text-curie-001";
-    OpenAiModels["babbage"] = "text-babbage-001";
-    OpenAiModels["ada"] = "text-ada-001";
-})(OpenAiModels = exports.OpenAiModels || (exports.OpenAiModels = {}));
-var AzureOpenAiModels;
-(function (AzureOpenAiModels) {
-    AzureOpenAiModels["davinci3"] = "text-davinci-003";
-    AzureOpenAiModels["davinci2"] = "text-davinci-002";
-    AzureOpenAiModels["curie"] = "text-curie-001";
-    AzureOpenAiModels["babbage"] = "text-babbage-001";
-    AzureOpenAiModels["ada"] = "text-ada-001";
-})(AzureOpenAiModels = exports.AzureOpenAiModels || (exports.AzureOpenAiModels = {}));
 //# sourceMappingURL=ai.js.map

package/build/shared/interfaces/amqpInterface.js

@@ -24,7 +24,9 @@ exports.referenceKeys = [
     "projectReference",
     "resourceReference",
     "snapshotReference",
-    "subResourceReference"
+    "subResourceReference",
+    "storeReference",
+    "sourceReference",
 ];
 exports.executeRpcInternalParamsSchema = {
     title: "executeRpcInternalParamsSchema",
@@ -82,6 +84,10 @@ exports.executeRpcInternalParamsSchema = {
         },
         expiration: {
             type: "string"
+        },
+        errorLogLevel: {
+            type: "string",
+            enum: ["error", "warn"],
         }
     }
 };

package/build/shared/interfaces/generativeAI/IGenerativeAIModels.js

@@ -0,0 +1,72 @@
+"use strict";
+/**********
+ * MODELS
+ **********/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modeType = exports.generativeAIUseCases = exports.generativeAIProviders = exports.generativeAIModels = void 0;
+/**
+ * @openapi
+ *
+ * components:
+ *   schemas:
+ *     TGenerativeAIModels:
+ *       type: string
+ *       enum:
+ *         - gpt-3.5-turbo
+ *         - text-davinci-003
+ *         - text-embedding-ada-002
+ *         - claude-v1-100k
+ *         - claude-instant-v1
+ *         - text-bison@001
+ */
+/**
+ * WARNING: if new models are added for the supported providers make suer we also update the
+ * maxAllowed tokens in the openAI.ts and azureOpenAI.ts files
+ */
+exports.generativeAIModels = [
+    "gpt-3.5-turbo",
+    "text-davinci-003",
+    "text-embedding-ada-002",
+    "claude-v1-100k",
+    "claude-instant-v1",
+    "text-bison@001"
+];
+/*************
+ * PROVIDERS
+ *************/
+/**
+ * @openapi
+ *
+ * components:
+ *   schemas:
+ *     TGenerativeAIProviders:
+ *       type: string
+ *       enum:
+ *         - azureOpenAI
+ *         - openAI
+ *         - anthropic
+ *         - googleVertexAI
+ */
+exports.generativeAIProviders = ["azureOpenAI", "openAI", "anthropic", "googleVertexAI"];
+/***********************
+ * COGNIGY.AI USE CASES
+ ***********************/
+/**
+ * WARNING: If you update the generativeAI useCases, please update the generativeAI
+ * mongoose schema too. models/settings/generativeAISettings.ts
+ */
+exports.generativeAIUseCases = [
+    "intentSentenceGeneration",
+    "aiEnhancedOutputs",
+    "lexiconGeneration",
+    "flowGeneration",
+    "gptConversation",
+    "gptPromptNode",
+    "generateNodeOutput",
+    "knowledgeSearch",
+];
+/************************
+ * GENERATIVE AI MODELS MODE TYPES
+ ************************/
+exports.modeType = ["completion", "chat", "embedding"];
+//# sourceMappingURL=IGenerativeAIModels.js.map

package/build/shared/interfaces/generativeAI/IGenerativeAIPrompts.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IGenerativeAIPrompts.js.map

package/build/shared/interfaces/generativeAI/IRunGenerativeAIPromptOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IRunGenerativeAIPromptOptions.js.map

package/build/shared/interfaces/handover.js

@@ -29,7 +29,16 @@ exports.handoverSettingsSchema = {
     properties: {
         provider: {
             type: "string",
-            enum: ["none", "chatwoot", "cognigy", "rce", "salesforce", "liveAgent", "genesysCloud", "eightByEight"]
+            enum: [
+                "none",
+                "chatwoot",
+                "cognigy",
+                "rce",
+                "salesforce",
+                "liveAgent",
+                "genesysCloud",
+                "eightByEight"
+            ]
         },
         providerSettings: {
             type: "object",
@@ -63,7 +72,7 @@ exports.handoverSettingsSchema = {
                         queue: { type: "string" },
                         queueId: { type: "string" },
                         sendProfile: { type: "boolean" },
-                        sessionDuration: { type: "number" },
+                        sessionDuration: { type: "number" }
                     }
                 }
             ]
@@ -74,6 +83,9 @@ exports.handoverSettingsSchema = {
             properties: {
                 agentAssistFlowId: { type: "string" },
                 agentAssistConfigId: { type: "string" },
+                enableTranscriptTile: { type: "boolean" },
+                enableTranscriptTileChatInput: { type: "boolean" },
+                redactTranscriptTileMessages: { type: "boolean" }
             }
         }
     }

package/build/shared/interfaces/knowledgesearch/search.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=search.js.map

package/build/shared/interfaces/messageAPI/ai.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSwitchedFlowData = exports.userSchema = void 0;
+exports.isSwitchedFlowData = exports.callRecordingActions = exports.userSchema = void 0;
 exports.userSchema = {
     title: "userSchema",
     type: "object",
@@ -15,6 +15,7 @@ exports.userSchema = {
         userId: { type: "string", minLength: 1 },
     },
 };
+exports.callRecordingActions = ["startCallRecording", "stopCallRecording", "pauseCallRecording", "resumeCallRecording"];
 /**
  * Type-Guard for "ISwitchedFlowData" in "AnyProcessOutputData"
  *