@or-sdk/knowledge-models 0.12.0

package/dist/cjs/KnowledgeModels.js

@@ -0,0 +1,1244 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeModels = void 0;
+var base_1 = require("@or-sdk/base");
+var utils_1 = require("./utils");
+var constants_1 = require("./constants");
+var KnowledgeModels = (function (_super) {
+    __extends(KnowledgeModels, _super);
+    function KnowledgeModels(params) {
+        var _this = this;
+        var token = params.token, discoveryUrl = params.discoveryUrl;
+        _this = _super.call(this, {
+            token: token,
+            discoveryUrl: discoveryUrl,
+            serviceKey: constants_1.SERVICE_KEY,
+        }) || this;
+        return _this;
+    }
+    KnowledgeModels.prototype.getFullList = function (method, route, queryParams) {
+        if (queryParams === void 0) { queryParams = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var params, result, list;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        params = __assign(__assign({}, queryParams), { last: undefined });
+                        list = [];
+                        _a.label = 1;
+                    case 1: return [4, this.callApi({
+                            method: method,
+                            route: route,
+                            params: params,
+                        })];
+                    case 2:
+                        result = _a.sent();
+                        list = __spreadArray(__spreadArray([], list, true), result.items, true);
+                        params.last = result.last;
+                        _a.label = 3;
+                    case 3:
+                        if (result.last && result.items.length) return [3, 1];
+                        _a.label = 4;
+                    case 4: return [2, (0, base_1.makeList)(list)];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.listKnowledgeModels = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.getFullList('GET', '/knowledge-base')];
+            });
+        });
+    };
+    KnowledgeModels.prototype.getKnowledgeModel = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var list;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.listKnowledgeModels()];
+                    case 1:
+                        list = _a.sent();
+                        return [2, list.rows.find(function (km) { return km.id === id; })];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.createKnowledgeModel = function (_a) {
+        var name = _a.name, desc = _a.desc, imageSrc = _a.imageSrc, config = _a.config, culture = _a.culture, extensions = _a.extensions;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    name: name,
+                    desc: desc,
+                    imageSrc: imageSrc,
+                    culture: culture,
+                    config: config,
+                    extensions: extensions,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/knowledge-base',
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.updateKnowledgeModel = function (knowledgeModel) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.callApi({
+                        method: 'PUT',
+                        route: '/knowledge-base',
+                        data: knowledgeModel,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.getLimitsIndex = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.callApi({
+                        method: 'GET',
+                        route: '/administration/limits/index',
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.getLimits = function (path) {
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_a) {
+                params = {
+                    path: path,
+                };
+                return [2, this.callApi({
+                        method: 'GET',
+                        route: '/administration/limits',
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.postLimits = function (_a) {
+        var accountId = _a.accountId, limits = _a.limits;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        data = {
+                            accountId: accountId,
+                            limits: limits,
+                        };
+                        return [4, this.callApi({
+                                method: 'POST',
+                                route: '/administration/limits',
+                                data: data,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.listPrebuiltEntities = function (_a) {
+        var _b = _a === void 0 ? {} : _a, language = _b.language;
+        return __awaiter(this, void 0, void 0, function () {
+            var params, result;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        params = {
+                            language: language,
+                        };
+                        return [4, this.callApi({
+                                method: 'GET',
+                                route: '/kb/entities/prebuilt/all',
+                                params: params,
+                            })];
+                    case 1:
+                        result = _c.sent();
+                        return [2, (0, base_1.makeList)(result)];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.listEntities = function (_a) {
+        var type = _a.type, kbId = _a.kbId, versionId = _a.versionId, limit = _a.limit;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    kbId: kbId,
+                    versionId: versionId,
+                    limit: limit,
+                };
+                return [2, this.getFullList('GET', "/kb/entities/".concat(type), params)];
+            });
+        });
+    };
+    KnowledgeModels.prototype.listFeatures = function (_a) {
+        var kbId = _a.kbId, versionId = _a.versionId, limit = _a.limit;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    kbId: kbId,
+                    versionId: versionId,
+                    limit: limit,
+                };
+                return [2, this.getFullList('GET', '/phraselists', params)];
+            });
+        });
+    };
+    KnowledgeModels.prototype.listApplications = function (_a) {
+        var kbId = _a.kbId, text = _a.text, pattern = _a.pattern, versionId = _a.versionId, limit = _a.limit, projection = _a.projection;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    kbId: kbId,
+                    limit: limit,
+                    text: text,
+                    pattern: pattern,
+                    versionId: versionId,
+                    projection: projection,
+                };
+                return [2, this.getFullList('GET', '/applications', params)];
+            });
+        });
+    };
+    KnowledgeModels.prototype.listIntentsLabels = function (_a) {
+        var appId = _a.appId, kbId = _a.kbId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    appId: appId,
+                    kbId: kbId,
+                };
+                return [2, this.callApi({
+                        method: 'GET',
+                        route: '/intents/labels',
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.listUtterances = function (_a) {
+        var kbId = _a.kbId, limit = _a.limit, query = __rest(_a, ["kbId", "limit"]);
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = __assign({ kbId: kbId, limit: limit }, query);
+                return [2, this.getFullList('GET', '/utterances', params)];
+            });
+        });
+    };
+    KnowledgeModels.prototype.listPatterns = function (_a) {
+        var kbId = _a.kbId, limit = _a.limit, query = __rest(_a, ["kbId", "limit"]);
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = __assign({ kbId: kbId, limit: limit }, query);
+                return [2, this.getFullList('GET', '/patterns', params)];
+            });
+        });
+    };
+    KnowledgeModels.prototype.listPrebuiltModels = function (_a) {
+        if (_a === void 0) { _a = {}; }
+        var limit = _a.limit, query = __rest(_a, ["limit"]);
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = __assign({ limit: limit }, query);
+                return [2, this.getFullList('GET', '/prebuilt-models', params)];
+            });
+        });
+    };
+    KnowledgeModels.prototype.removePrebuiltModelFromKM = function (_a) {
+        var prebuiltModelId = _a.prebuiltModelId, kbId = _a.kbId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        params = {
+                            prebuiltModelId: prebuiltModelId,
+                            kbId: kbId,
+                        };
+                        return [4, this.callApi({
+                                method: 'DELETE',
+                                route: '/knowledge-base/prebuilt-model',
+                                params: params,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.addPrebuiltModelToKM = function (_a) {
+        var kbId = _a.kbId, prebuiltModelId = _a.prebuiltModelId, appId = _a.appId, appName = _a.appName, shouldCreateNewApplication = _a.shouldCreateNewApplication, responses = _a.responses, entities = _a.entities;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                data = {
+                    kbId: kbId,
+                    appId: appId,
+                    prebuiltModelId: prebuiltModelId,
+                    appName: appName,
+                    shouldCreateNewApplication: shouldCreateNewApplication,
+                    responses: responses,
+                    entities: entities,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/knowledge-base/prebuilt-model',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.getPrebuiltModelDetails = function (_a) {
+        var kbId = _a.kbId, prebuiltModelId = _a.prebuiltModelId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    kbId: kbId,
+                    prebuiltModelId: prebuiltModelId,
+                };
+                return [2, this.callApi({
+                        method: 'GET',
+                        route: '/knowledge-base/prebuilt-model',
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.createApplication = function (_a) {
+        var kbId = _a.kbId, name = _a.name, desc = _a.desc, culture = _a.culture, model_features = _a.model_features;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                data = {
+                    kbId: kbId,
+                    name: name,
+                    desc: desc,
+                    culture: culture,
+                    model_features: model_features,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/applications',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.createIntent = function (_a) {
+        var name = _a.name, type = _a.type, kbId = _a.kbId, appId = _a.appId, postprocessFlows = _a.postprocessFlows, customData = _a.customData, features = _a.features;
+        return __awaiter(this, void 0, void 0, function () {
+            var data, params;
+            return __generator(this, function (_b) {
+                data = {
+                    name: name,
+                    type: type,
+                    postprocessFlows: postprocessFlows,
+                    customData: customData,
+                    features: features,
+                };
+                params = {
+                    kbId: kbId,
+                    appId: appId,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/intents',
+                        data: data,
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.createUtterance = function (_a) {
+        var appId = _a.appId, kbId = _a.kbId, autoGenerated = _a.autoGenerated, text = _a.text, intent = _a.intent, entities = _a.entities;
+        return __awaiter(this, void 0, void 0, function () {
+            var data, params;
+            return __generator(this, function (_b) {
+                data = {
+                    autoGenerated: autoGenerated,
+                    text: text,
+                    intent: intent,
+                    entities: entities,
+                };
+                params = {
+                    kbId: kbId,
+                    appId: appId,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/utterances',
+                        data: data,
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.createPattern = function (_a) {
+        var appId = _a.appId, kbId = _a.kbId, pattern = _a.pattern, intent = _a.intent, entities = _a.entities;
+        return __awaiter(this, void 0, void 0, function () {
+            var data, params;
+            return __generator(this, function (_b) {
+                data = {
+                    pattern: pattern,
+                    intent: intent,
+                    entities: entities,
+                };
+                params = {
+                    kbId: kbId,
+                    appId: appId,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/patterns',
+                        data: data,
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.createPair = function (_a) {
+        var kbId = _a.kbId, applicationName = _a.applicationName, intentName = _a.intentName, intentType = _a.intentType, utteranceText = _a.utteranceText;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                data = {
+                    kbId: kbId,
+                    applicationName: applicationName,
+                    intentName: intentName,
+                    intentType: intentType,
+                    utteranceText: utteranceText,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/knowledge-base/pair',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.batchCreatePairs = function (_a) {
+        var kbId = _a.kbId, utterances = _a.utterances;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                data = {
+                    kbId: kbId,
+                    utterances: utterances,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/knowledge-base/pairs',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.batchCreatePairsFile = function (_a) {
+        var kbId = _a.kbId, fileUrl = _a.fileUrl;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                data = {
+                    kbId: kbId,
+                    fileUrl: fileUrl,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/knowledge-base/pairs/file',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.createPatternPair = function (_a) {
+        var kbId = _a.kbId, applicationName = _a.applicationName, intentName = _a.intentName, intentType = _a.intentType, patternText = _a.patternText, patternEntities = _a.patternEntities;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                data = {
+                    kbId: kbId,
+                    applicationName: applicationName,
+                    intentName: intentName,
+                    intentType: intentType,
+                    patternText: patternText,
+                    patternEntities: patternEntities,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/knowledge-base/patterns/pair',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.createPairsCsv = function (_a) {
+        var kbId = _a.kbId, fileUrl = _a.fileUrl, applicationName = _a.applicationName, delimiter = _a.delimiter;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                data = {
+                    kbId: kbId,
+                    applicationName: applicationName,
+                    fileUrl: fileUrl,
+                    delimiter: delimiter,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/knowledge-base/pair/csv',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.createEntity = function (_a) {
+        var type = _a.type, kbId = _a.kbId, name = _a.name, roles = _a.roles, rest = __rest(_a, ["type", "kbId", "name", "roles"]);
+        return __awaiter(this, void 0, void 0, function () {
+            var data, params;
+            return __generator(this, function (_b) {
+                data = (0, utils_1.getEntityBody)(type, __assign({ name: name, roles: roles }, rest));
+                params = {
+                    kbId: kbId,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: "/kb/entities/".concat(type),
+                        data: data,
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.createFeature = function (_a) {
+        var kbId = _a.kbId, name = _a.name, mode = _a.mode, words = _a.words, enabledForAllModels = _a.enabledForAllModels;
+        return __awaiter(this, void 0, void 0, function () {
+            var data, params;
+            return __generator(this, function (_b) {
+                data = {
+                    name: name,
+                    mode: mode,
+                    words: words,
+                    enabledForAllModels: enabledForAllModels,
+                };
+                params = {
+                    kbId: kbId,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/phraselists',
+                        data: data,
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.updateApplication = function (_a) {
+        var kbId = _a.kbId, id = _a.id, name = _a.name, desc = _a.desc, model_features = _a.model_features;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                data = {
+                    kbId: kbId,
+                    id: id,
+                    name: name,
+                    desc: desc,
+                    model_features: model_features,
+                };
+                return [2, this.callApi({
+                        method: 'PUT',
+                        route: '/applications',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.updateIntent = function (_a) {
+        var name = _a.name, type = _a.type, id = _a.id, appId = _a.appId, kbId = _a.kbId, postprocessFlows = _a.postprocessFlows, customData = _a.customData, features = _a.features;
+        return __awaiter(this, void 0, void 0, function () {
+            var data, params;
+            return __generator(this, function (_b) {
+                data = {
+                    name: name,
+                    type: type,
+                    postprocessFlows: postprocessFlows,
+                    customData: customData,
+                    features: features,
+                };
+                params = {
+                    id: id,
+                    kbId: kbId,
+                    appId: appId,
+                };
+                return [2, this.callApi({
+                        method: 'PUT',
+                        route: '/intents',
+                        data: data,
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.updateUtterance = function (_a) {
+        var appId = _a.appId, kbId = _a.kbId, utterance = _a.utterance;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    kbId: kbId,
+                    appId: appId,
+                };
+                return [2, this.callApi({
+                        method: 'PUT',
+                        route: '/utterances',
+                        data: utterance,
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.updatePattern = function (_a) {
+        var appId = _a.appId, kbId = _a.kbId, pattern = _a.pattern;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    kbId: kbId,
+                    appId: appId,
+                };
+                return [2, this.callApi({
+                        method: 'PUT',
+                        route: '/patterns',
+                        data: pattern,
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.updatePair = function (_a) {
+        var kbId = _a.kbId, applicationName = _a.applicationName, intentName = _a.intentName, intentType = _a.intentType, utterance = _a.utterance;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        data = {
+                            kbId: kbId,
+                            applicationName: applicationName,
+                            intentName: intentName,
+                            intentType: intentType,
+                            utterance: utterance,
+                        };
+                        return [4, this.callApi({
+                                method: 'PUT',
+                                route: '/knowledge-base/pair',
+                                data: data,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.batchUpdatePairs = function (_a) {
+        var kbId = _a.kbId, utterances = _a.utterances;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    kbId: kbId,
+                };
+                return [2, this.callApi({
+                        method: 'PUT',
+                        route: '/knowledge-base/pairs',
+                        data: utterances,
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.updateEntity = function (_a) {
+        var type = _a.type, id = _a.id, kbId = _a.kbId, name = _a.name, roles = _a.roles, rest = __rest(_a, ["type", "id", "kbId", "name", "roles"]);
+        return __awaiter(this, void 0, void 0, function () {
+            var data, params;
+            return __generator(this, function (_b) {
+                data = (0, utils_1.getEntityBody)(type, __assign({ name: name, roles: roles }, rest));
+                params = {
+                    id: id,
+                    kbId: kbId,
+                };
+                return [2, this.callApi({
+                        method: 'PUT',
+                        route: "/kb/entities/".concat(type),
+                        data: data,
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.updateFeature = function (_a) {
+        var kbId = _a.kbId, id = _a.id, name = _a.name, mode = _a.mode, words = _a.words, enabledForAllModels = _a.enabledForAllModels, _b = _a.activated, activated = _b === void 0 ? true : _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var data, params;
+            return __generator(this, function (_c) {
+                data = {
+                    name: name,
+                    mode: mode,
+                    words: words,
+                    enabledForAllModels: enabledForAllModels,
+                    activated: activated,
+                };
+                params = {
+                    id: id,
+                    kbId: kbId,
+                };
+                return [2, this.callApi({
+                        method: 'PUT',
+                        route: '/phraselists',
+                        data: data,
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.updatePrebuiltEntities = function (_a) {
+        var kbId = _a.kbId, id = _a.id, entity = _a.entity;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    kbId: kbId,
+                    id: id,
+                };
+                return [2, this.callApi({
+                        method: 'PUT',
+                        route: '/kb/entities/prebuilt',
+                        data: entity,
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.deleteKnowledgeBase = function (_a) {
+        var id = _a.id;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        params = {
+                            id: id,
+                        };
+                        return [4, this.callApi({
+                                method: 'DELETE',
+                                route: '/knowledge-base',
+                                params: params,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.deleteApplication = function (_a) {
+        var kbId = _a.kbId, appId = _a.appId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        params = {
+                            kbId: kbId,
+                            appId: appId,
+                        };
+                        return [4, this.callApi({
+                                method: 'DELETE',
+                                route: '/applications',
+                                params: params,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.deleteIntent = function (_a) {
+        var id = _a.id, appId = _a.appId, kbId = _a.kbId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        params = {
+                            id: id,
+                            kbId: kbId,
+                            appId: appId,
+                            deleteUtterances: true,
+                        };
+                        return [4, this.callApi({
+                                method: 'DELETE',
+                                route: '/intents',
+                                params: params,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.deleteUtterance = function (_a) {
+        var id = _a.id, kbId = _a.kbId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        params = {
+                            id: id,
+                            kbId: kbId,
+                        };
+                        return [4, this.callApi({
+                                method: 'DELETE',
+                                route: '/utterances',
+                                params: params,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.batchDeleteUtterances = function (_a) {
+        var ids = _a.ids, kbId = _a.kbId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        params = {
+                            kbId: kbId,
+                        };
+                        return [4, this.callApi({
+                                method: 'POST',
+                                route: '/utterances/bulk/delete',
+                                params: params,
+                                data: ids,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.deletePattern = function (_a) {
+        var id = _a.id, kbId = _a.kbId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        params = {
+                            id: id,
+                            kbId: kbId,
+                        };
+                        return [4, this.callApi({
+                                method: 'DELETE',
+                                route: '/patterns',
+                                params: params,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.deleteEntity = function (_a) {
+        var type = _a.type, id = _a.id, kbId = _a.kbId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        params = {
+                            id: id,
+                            kbId: kbId,
+                        };
+                        return [4, this.callApi({
+                                method: 'DELETE',
+                                route: "/kb/entities/".concat(type),
+                                params: params,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.deleteFeature = function (_a) {
+        var id = _a.id, kbId = _a.kbId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        params = {
+                            id: id,
+                            kbId: kbId,
+                        };
+                        return [4, this.callApi({
+                                method: 'DELETE',
+                                route: '/phraselists',
+                                params: params,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.getTrainStatus = function (_a) {
+        var kbId = _a.kbId, _b = _a.versionId, versionId = _b === void 0 ? null : _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_c) {
+                params = {
+                    kbId: kbId,
+                    versionId: versionId,
+                };
+                return [2, this.callApi({
+                        method: 'GET',
+                        route: '/train/status',
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.train = function (_a) {
+        var kbId = _a.kbId, flowId = _a.flowId, phraseId = _a.phraseId, sessionId = _a.sessionId, autoPublish = _a.autoPublish;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    kbId: kbId,
+                    flowId: flowId,
+                    phraseId: phraseId,
+                    sessionId: sessionId,
+                    autoPublish: autoPublish,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/kb/train',
+                        params: params,
+                        data: null,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.trainForTest = function (_a) {
+        var kbId = _a.kbId, flowId = _a.flowId, phraseId = _a.phraseId, sessionId = _a.sessionId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    kbId: kbId,
+                    flowId: flowId,
+                    phraseId: phraseId,
+                    sessionId: sessionId,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/kb/train/test',
+                        params: params,
+                        data: null,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.publish = function (_a) {
+        var kbId = _a.kbId, _b = _a.versionId, versionId = _b === void 0 ? null : _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_c) {
+                params = {
+                    kbId: kbId,
+                    versionId: versionId,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/kb/publish',
+                        params: params,
+                        data: null,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.recover = function (_a) {
+        var kbId = _a.kbId, versionId = _a.versionId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        params = {
+                            kbId: kbId,
+                            versionId: versionId,
+                        };
+                        return [4, this.callApi({
+                                method: 'POST',
+                                route: '/kb/recover',
+                                params: params,
+                                data: null,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.deleteVersion = function (_a) {
+        var kbId = _a.kbId, versionId = _a.versionId;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        params = {
+                            kbId: kbId,
+                            versionId: versionId,
+                        };
+                        return [4, this.callApi({
+                                method: 'DELETE',
+                                route: '/kb/versions',
+                                params: params,
+                            })];
+                    case 1:
+                        _b.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    KnowledgeModels.prototype.clone = function (_a) {
+        var kbId = _a.kbId, newName = _a.newName;
+        return __awaiter(this, void 0, void 0, function () {
+            var data, params;
+            return __generator(this, function (_b) {
+                data = {
+                    newName: newName,
+                };
+                params = {
+                    id: kbId,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/knowledge-base/clone',
+                        params: params,
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.export = function (_a) {
+        var kbId = _a.kbId, isPublic = _a.isPublic;
+        return __awaiter(this, void 0, void 0, function () {
+            var params;
+            return __generator(this, function (_b) {
+                params = {
+                    id: kbId,
+                    isPublic: isPublic,
+                };
+                return [2, this.callApi({
+                        method: 'GET',
+                        route: '/knowledge-base/export',
+                        params: params,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.import = function (_a) {
+        var fileUrl = _a.fileUrl, knowledgeBase = _a.knowledgeBase;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                data = {
+                    fileUrl: fileUrl,
+                    knowledgeBase: knowledgeBase,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/knowledge-base/import',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.importJson = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/knowledge-base/import/json',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.importCsv = function (_a) {
+        var fileUrl = _a.fileUrl, knowledgeBase = _a.knowledgeBase, applicationName = _a.applicationName, delimiter = _a.delimiter;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                data = {
+                    fileUrl: fileUrl,
+                    knowledgeBase: knowledgeBase,
+                    applicationName: applicationName,
+                    delimiter: delimiter,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/knowledge-base/import/csv',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.meaning = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/meaning',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    KnowledgeModels.prototype.testMeaning = function (_a) {
+        var q = _a.q, appId = _a.appId, kbId = _a.kbId;
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_b) {
+                data = {
+                    q: q,
+                    appId: appId,
+                    kbId: kbId,
+                };
+                return [2, this.callApi({
+                        method: 'POST',
+                        route: '/meaning/test',
+                        data: data,
+                    })];
+            });
+        });
+    };
+    return KnowledgeModels;
+}(base_1.Base));
+exports.KnowledgeModels = KnowledgeModels;
+//# sourceMappingURL=KnowledgeModels.js.map