@or-sdk/knowledge-models 0.24.3 → 0.25.0-beta.598.0

package/dist/esm/KnowledgeModels.js

@@ -1,23 +1,3 @@
-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 __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;
-};
 import { Base, makeList } from '@or-sdk/base';
 import { getEntityBody } from './utils';
 import { SERVICE_KEY } from './constants';
@@ -31,830 +11,723 @@ export class KnowledgeModels extends Base {
             serviceUrl: nluUrl,
         });
     }
-    getFullList(method, route, queryParams = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = Object.assign(Object.assign({}, queryParams), { last: undefined });
-            let result;
-            let list = [];
-            do {
-                result = yield this.callApi({
-                    method,
-                    route,
-                    params,
-                });
-                list = [...list, ...result.items];
-                params.last = result.last;
-            } while (result.last && result.items.length);
-            return makeList(list);
-        });
-    }
-    listKnowledgeModels() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getFullList('GET', '/knowledge-base');
-        });
-    }
-    getKnowledgeModel(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const list = yield this.listKnowledgeModels();
-            return list.items.find(km => km.id === id);
-        });
-    }
-    createKnowledgeModel({ name, desc, imageSrc, config, culture, extensions }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                name,
-                desc,
-                imageSrc,
-                culture,
-                config,
-                extensions,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/knowledge-base',
-                data,
-            });
-        });
-    }
-    updateKnowledgeModel(knowledgeModel) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.callApi({
-                method: 'PUT',
-                route: '/knowledge-base',
-                data: knowledgeModel,
-            });
-        });
-    }
-    getLimitsIndex() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.callApi({
-                method: 'GET',
-                route: '/administration/limits/index',
-            });
-        });
-    }
-    getLimits(path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                path,
-            };
-            return this.callApi({
-                method: 'GET',
-                route: '/administration/limits',
-                params,
-            });
-        });
-    }
-    postLimits({ accountId, limits }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                accountId,
-                limits,
-            };
-            yield this.callApi({
-                method: 'POST',
-                route: '/administration/limits',
-                data,
-            });
-        });
-    }
-    listPrebuiltEntities({ language } = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                language,
-            };
-            const result = yield this.callApi({
-                method: 'GET',
-                route: '/kb/entities/prebuilt/all',
-                params,
-            });
-            return makeList(result);
-        });
-    }
-    listEntities({ type, kbId, versionId, limit }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                versionId,
-                limit,
-            };
-            return this.getFullList('GET', `/kb/entities/${type}`, params);
-        });
-    }
-    listFeatures({ kbId, versionId, limit }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                versionId,
-                limit,
-            };
-            return this.getFullList('GET', '/phraselists', params);
-        });
-    }
-    listApplications({ kbId, text, pattern, versionId, limit, projection }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                limit,
-                text,
-                pattern,
-                versionId,
-                projection,
-            };
-            return this.getFullList('GET', '/applications', params);
-        });
-    }
-    listIntentsLabels({ appId, kbId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                appId,
-                kbId,
-            };
-            return this.callApi({
-                method: 'GET',
-                route: '/intents/labels',
-                params,
-            });
-        });
-    }
-    listUtterances(_a) {
-        var { kbId, limit } = _a, query = __rest(_a, ["kbId", "limit"]);
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = Object.assign({ kbId,
-                limit }, query);
-            return this.getFullList('GET', '/utterances', params);
-        });
-    }
-    listPatterns(_a) {
-        var { kbId, limit } = _a, query = __rest(_a, ["kbId", "limit"]);
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = Object.assign({ kbId,
-                limit }, query);
-            return this.getFullList('GET', '/patterns', params);
-        });
-    }
-    listPrebuiltModels(_a = {}) {
-        var { limit } = _a, query = __rest(_a, ["limit"]);
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = Object.assign({ limit }, query);
-            return this.getFullList('GET', '/prebuilt-models', params);
-        });
-    }
-    removePrebuiltModelFromKM({ prebuiltModelId, kbId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                prebuiltModelId,
-                kbId,
-            };
-            yield this.callApi({
-                method: 'DELETE',
-                route: '/knowledge-base/prebuilt-model',
-                params,
-            });
-        });
-    }
-    addPrebuiltModelToKM({ kbId, prebuiltModelId, appId, appName, shouldCreateNewApplication, responses, entities, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                kbId,
-                appId,
-                prebuiltModelId,
-                appName,
-                shouldCreateNewApplication,
-                responses,
-                entities,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/knowledge-base/prebuilt-model',
-                data,
-            });
-        });
-    }
-    getPrebuiltModelDetails({ kbId, prebuiltModelId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                prebuiltModelId,
-            };
-            return this.callApi({
-                method: 'GET',
-                route: '/knowledge-base/prebuilt-model',
-                params,
-            });
-        });
-    }
-    createApplication({ kbId, name, desc, culture, model_features }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                kbId,
-                name,
-                desc,
-                culture,
-                model_features,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/applications',
-                data,
-            });
-        });
-    }
-    createIntent({ name, type, kbId, appId, postprocessFlows, customData, features }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                name,
-                type,
-                postprocessFlows,
-                customData,
-                features,
-            };
-            const params = {
-                kbId,
-                appId,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/intents',
-                data,
-                params,
-            });
-        });
-    }
-    createUtterance({ appId, kbId, autoGenerated, text, intent, entities }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                autoGenerated,
-                text,
-                intent,
-                entities,
-            };
-            const params = {
-                kbId,
-                appId,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/utterances',
-                data,
-                params,
-            });
-        });
-    }
-    createPattern({ appId, kbId, pattern, intent, entities }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                pattern,
-                intent,
-                entities,
-            };
-            const params = {
-                kbId,
-                appId,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/patterns',
-                data,
-                params,
-            });
-        });
-    }
-    createPair({ kbId, applicationName, intentName, intentType, utteranceText }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                kbId,
-                applicationName,
-                intentName,
-                intentType,
-                utteranceText,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/knowledge-base/pair',
-                data,
-            });
-        });
-    }
-    batchCreatePairs({ kbId, utterances }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                kbId,
-                utterances,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/knowledge-base/pairs',
-                data,
-            });
-        });
-    }
-    batchCreatePairsFile({ kbId, fileUrl }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                kbId,
-                fileUrl,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/knowledge-base/pairs/file',
-                data,
-            });
-        });
-    }
-    createPatternPair({ kbId, applicationName, intentName, intentType, patternText, patternEntities }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                kbId,
-                applicationName,
-                intentName,
-                intentType,
-                patternText,
-                patternEntities,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/knowledge-base/patterns/pair',
-                data,
-            });
-        });
-    }
-    createPairsCsv({ kbId, fileUrl, applicationName, delimiter }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                kbId,
-                applicationName,
-                fileUrl,
-                delimiter,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/knowledge-base/pair/csv',
-                data,
-            });
-        });
-    }
-    createEntity(_a) {
-        var { type, kbId, name, roles } = _a, rest = __rest(_a, ["type", "kbId", "name", "roles"]);
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = getEntityBody(type, Object.assign({ name,
-                roles }, rest));
-            const params = {
-                kbId,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: `/kb/entities/${type}`,
-                data,
-                params,
-            });
-        });
-    }
-    createFeature({ kbId, name, mode, words, enabledForAllModels }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                name,
-                mode,
-                words,
-                enabledForAllModels,
-            };
-            const params = {
-                kbId,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/phraselists',
-                data,
-                params,
-            });
-        });
-    }
-    updateApplication({ kbId, id, name, desc, model_features }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                kbId,
-                id,
-                name,
-                desc,
-                model_features,
-            };
-            return this.callApi({
-                method: 'PUT',
-                route: '/applications',
-                data: data,
-            });
-        });
-    }
-    updateIntent({ name, type, id, appId, kbId, postprocessFlows, customData, features }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                name,
-                type,
-                postprocessFlows,
-                customData,
-                features,
-            };
-            const params = {
-                id,
-                kbId,
-                appId,
-            };
-            return this.callApi({
-                method: 'PUT',
-                route: '/intents',
-                data,
-                params,
-            });
-        });
-    }
-    updateUtterance({ appId, kbId, utterance }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                appId,
-            };
-            return this.callApi({
-                method: 'PUT',
-                route: '/utterances',
-                data: utterance,
-                params,
-            });
-        });
-    }
-    updatePattern({ appId, kbId, pattern }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                appId,
-            };
-            return this.callApi({
-                method: 'PUT',
-                route: '/patterns',
-                data: pattern,
-                params,
-            });
-        });
-    }
-    updatePair({ kbId, applicationName, intentName, intentType, utterance }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                kbId,
-                applicationName,
-                intentName,
-                intentType,
-                utterance,
-            };
-            yield this.callApi({
-                method: 'PUT',
-                route: '/knowledge-base/pair',
-                data,
-            });
-        });
-    }
-    batchUpdatePairs({ kbId, utterances }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-            };
-            return this.callApi({
-                method: 'PUT',
-                route: '/knowledge-base/pairs',
-                data: utterances,
-                params,
-            });
-        });
-    }
-    updateEntity(_a) {
-        var { type, id, kbId, name, roles } = _a, rest = __rest(_a, ["type", "id", "kbId", "name", "roles"]);
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = getEntityBody(type, Object.assign({ name,
-                roles }, rest));
-            const params = {
-                id,
-                kbId,
-            };
-            return this.callApi({
-                method: 'PUT',
-                route: `/kb/entities/${type}`,
-                data,
-                params,
-            });
-        });
-    }
-    updateFeature({ kbId, id, name, mode, words, enabledForAllModels, activated = true }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                name,
-                mode,
-                words,
-                enabledForAllModels,
-                activated,
-            };
-            const params = {
-                id,
-                kbId,
-            };
-            return this.callApi({
-                method: 'PUT',
-                route: '/phraselists',
-                data,
-                params,
-            });
-        });
-    }
-    updatePrebuiltEntities({ kbId, id, entity }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                id,
-            };
-            return this.callApi({
-                method: 'PUT',
-                route: '/kb/entities/prebuilt',
-                data: entity,
-                params,
-            });
-        });
-    }
-    deleteKnowledgeBase({ id }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                id,
-            };
-            yield this.callApi({
-                method: 'DELETE',
-                route: '/knowledge-base',
-                params,
-            });
-        });
-    }
-    deleteApplication({ kbId, appId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                appId,
-            };
-            yield this.callApi({
-                method: 'DELETE',
-                route: '/applications',
-                params,
-            });
-        });
-    }
-    deleteIntent({ id, appId, kbId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                id,
-                kbId,
-                appId,
-                deleteUtterances: true,
-            };
-            yield this.callApi({
-                method: 'DELETE',
-                route: '/intents',
-                params,
-            });
-        });
-    }
-    deleteUtterance({ id, kbId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                id,
-                kbId,
-            };
-            yield this.callApi({
-                method: 'DELETE',
-                route: '/utterances',
-                params,
-            });
-        });
-    }
-    batchDeleteUtterances({ ids, kbId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-            };
-            yield this.callApi({
-                method: 'POST',
-                route: '/utterances/bulk/delete',
-                params,
-                data: ids,
-            });
-        });
-    }
-    deletePattern({ id, kbId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                id,
-                kbId,
-            };
-            yield this.callApi({
-                method: 'DELETE',
-                route: '/patterns',
-                params,
-            });
-        });
-    }
-    deleteEntity({ type, id, kbId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                id,
-                kbId,
-            };
-            yield this.callApi({
-                method: 'DELETE',
-                route: `/kb/entities/${type}`,
-                params,
-            });
-        });
-    }
-    deleteFeature({ id, kbId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                id,
-                kbId,
-            };
-            yield this.callApi({
-                method: 'DELETE',
-                route: '/phraselists',
-                params,
-            });
-        });
-    }
-    getTrainStatus({ kbId, versionId = null }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                versionId,
-            };
-            return this.callApi({
-                method: 'GET',
-                route: '/train/status',
-                params,
-            });
-        });
-    }
-    train({ kbId, flowId, phraseId, sessionId, autoPublish }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                flowId,
-                phraseId,
-                sessionId,
-                autoPublish,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/kb/train',
-                params,
-                data: null,
-            });
-        });
-    }
-    trainForTest({ kbId, flowId, phraseId, sessionId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                flowId,
-                phraseId,
-                sessionId,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/kb/train/test',
-                params,
-                data: null,
-            });
-        });
-    }
-    publish({ kbId, versionId = null }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                versionId,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/kb/publish',
-                params,
-                data: null,
-            });
-        });
-    }
-    recover({ kbId, versionId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                versionId,
-            };
-            yield this.callApi({
-                method: 'POST',
-                route: '/kb/recover',
-                params,
-                data: null,
-            });
-        });
-    }
-    deleteVersion({ kbId, versionId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                kbId,
-                versionId,
-            };
-            yield this.callApi({
-                method: 'DELETE',
-                route: '/kb/versions',
-                params,
-            });
-        });
-    }
-    clone({ kbId, newName }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                newName,
-            };
-            const params = {
-                id: kbId,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/knowledge-base/clone',
-                params,
-                data,
-            });
-        });
-    }
-    export({ kbId, isPublic }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                id: kbId,
-                isPublic,
-            };
-            return this.callApi({
-                method: 'GET',
-                route: '/knowledge-base/export',
-                params,
-            });
-        });
-    }
-    import({ fileUrl, knowledgeBase }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                fileUrl,
-                knowledgeBase,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/knowledge-base/import',
-                data,
-            });
-        });
-    }
-    importJson(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.callApi({
-                method: 'POST',
-                route: '/knowledge-base/import/json',
-                data,
-            });
-        });
-    }
-    importCsv({ fileUrl, knowledgeBase, applicationName, delimiter }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                fileUrl,
-                knowledgeBase,
-                applicationName,
-                delimiter,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/knowledge-base/import/csv',
-                data,
-            });
-        });
-    }
-    meaning(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.callApi({
-                method: 'POST',
-                route: '/meaning',
-                data,
-            });
-        });
-    }
-    testMeaning({ q, appId, kbId }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = {
-                q,
-                appId,
-                kbId,
-            };
-            return this.callApi({
-                method: 'POST',
-                route: '/meaning/test',
-                data,
-            });
+    async getFullList(method, route, queryParams = {}) {
+        const params = {
+            ...queryParams,
+            last: undefined,
+        };
+        let result;
+        let list = [];
+        do {
+            result = await this.callApi({
+                method,
+                route,
+                params,
+            });
+            list = [...list, ...result.items];
+            params.last = result.last;
+        } while (result.last && result.items.length);
+        return makeList(list);
+    }
+    async listKnowledgeModels() {
+        return this.getFullList('GET', '/knowledge-base');
+    }
+    async getKnowledgeModel(id) {
+        const list = await this.listKnowledgeModels();
+        return list.items.find(km => km.id === id);
+    }
+    async createKnowledgeModel({ name, desc, imageSrc, config, culture, extensions }) {
+        const data = {
+            name,
+            desc,
+            imageSrc,
+            culture,
+            config,
+            extensions,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/knowledge-base',
+            data,
+        });
+    }
+    async updateKnowledgeModel(knowledgeModel) {
+        return this.callApi({
+            method: 'PUT',
+            route: '/knowledge-base',
+            data: knowledgeModel,
+        });
+    }
+    async getLimitsIndex() {
+        return this.callApi({
+            method: 'GET',
+            route: '/administration/limits/index',
+        });
+    }
+    async getLimits(path) {
+        const params = {
+            path,
+        };
+        return this.callApi({
+            method: 'GET',
+            route: '/administration/limits',
+            params,
+        });
+    }
+    async postLimits({ accountId, limits }) {
+        const data = {
+            accountId,
+            limits,
+        };
+        await this.callApi({
+            method: 'POST',
+            route: '/administration/limits',
+            data,
+        });
+    }
+    async listPrebuiltEntities({ language } = {}) {
+        const params = {
+            language,
+        };
+        const result = await this.callApi({
+            method: 'GET',
+            route: '/kb/entities/prebuilt/all',
+            params,
+        });
+        return makeList(result);
+    }
+    async listEntities({ type, kbId, versionId, limit }) {
+        const params = {
+            kbId,
+            versionId,
+            limit,
+        };
+        return this.getFullList('GET', `/kb/entities/${type}`, params);
+    }
+    async listFeatures({ kbId, versionId, limit }) {
+        const params = {
+            kbId,
+            versionId,
+            limit,
+        };
+        return this.getFullList('GET', '/phraselists', params);
+    }
+    async listApplications({ kbId, text, pattern, versionId, limit, projection }) {
+        const params = {
+            kbId,
+            limit,
+            text,
+            pattern,
+            versionId,
+            projection,
+        };
+        return this.getFullList('GET', '/applications', params);
+    }
+    async listIntentsLabels({ appId, kbId }) {
+        const params = {
+            appId,
+            kbId,
+        };
+        return this.callApi({
+            method: 'GET',
+            route: '/intents/labels',
+            params,
+        });
+    }
+    async listUtterances({ kbId, limit, ...query }) {
+        const params = {
+            kbId,
+            limit,
+            ...query,
+        };
+        return this.getFullList('GET', '/utterances', params);
+    }
+    async listPatterns({ kbId, limit, ...query }) {
+        const params = {
+            kbId,
+            limit,
+            ...query,
+        };
+        return this.getFullList('GET', '/patterns', params);
+    }
+    async listPrebuiltModels({ limit, ...query } = {}) {
+        const params = {
+            limit,
+            ...query,
+        };
+        return this.getFullList('GET', '/prebuilt-models', params);
+    }
+    async removePrebuiltModelFromKM({ prebuiltModelId, kbId }) {
+        const params = {
+            prebuiltModelId,
+            kbId,
+        };
+        await this.callApi({
+            method: 'DELETE',
+            route: '/knowledge-base/prebuilt-model',
+            params,
+        });
+    }
+    async addPrebuiltModelToKM({ kbId, prebuiltModelId, appId, appName, shouldCreateNewApplication, responses, entities, }) {
+        const data = {
+            kbId,
+            appId,
+            prebuiltModelId,
+            appName,
+            shouldCreateNewApplication,
+            responses,
+            entities,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/knowledge-base/prebuilt-model',
+            data,
+        });
+    }
+    async getPrebuiltModelDetails({ kbId, prebuiltModelId }) {
+        const params = {
+            kbId,
+            prebuiltModelId,
+        };
+        return this.callApi({
+            method: 'GET',
+            route: '/knowledge-base/prebuilt-model',
+            params,
+        });
+    }
+    async createApplication({ kbId, name, desc, culture, model_features }) {
+        const data = {
+            kbId,
+            name,
+            desc,
+            culture,
+            model_features,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/applications',
+            data,
+        });
+    }
+    async createIntent({ name, type, kbId, appId, postprocessFlows, customData, features }) {
+        const data = {
+            name,
+            type,
+            postprocessFlows,
+            customData,
+            features,
+        };
+        const params = {
+            kbId,
+            appId,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/intents',
+            data,
+            params,
+        });
+    }
+    async createUtterance({ appId, kbId, autoGenerated, text, intent, entities }) {
+        const data = {
+            autoGenerated,
+            text,
+            intent,
+            entities,
+        };
+        const params = {
+            kbId,
+            appId,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/utterances',
+            data,
+            params,
+        });
+    }
+    async createPattern({ appId, kbId, pattern, intent, entities }) {
+        const data = {
+            pattern,
+            intent,
+            entities,
+        };
+        const params = {
+            kbId,
+            appId,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/patterns',
+            data,
+            params,
+        });
+    }
+    async createPair({ kbId, applicationName, intentName, intentType, utteranceText }) {
+        const data = {
+            kbId,
+            applicationName,
+            intentName,
+            intentType,
+            utteranceText,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/knowledge-base/pair',
+            data,
+        });
+    }
+    async batchCreatePairs({ kbId, utterances }) {
+        const data = {
+            kbId,
+            utterances,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/knowledge-base/pairs',
+            data,
+        });
+    }
+    async batchCreatePairsFile({ kbId, fileUrl }) {
+        const data = {
+            kbId,
+            fileUrl,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/knowledge-base/pairs/file',
+            data,
+        });
+    }
+    async createPatternPair({ kbId, applicationName, intentName, intentType, patternText, patternEntities }) {
+        const data = {
+            kbId,
+            applicationName,
+            intentName,
+            intentType,
+            patternText,
+            patternEntities,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/knowledge-base/patterns/pair',
+            data,
+        });
+    }
+    async createPairsCsv({ kbId, fileUrl, applicationName, delimiter }) {
+        const data = {
+            kbId,
+            applicationName,
+            fileUrl,
+            delimiter,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/knowledge-base/pair/csv',
+            data,
+        });
+    }
+    async createEntity({ type, kbId, name, roles, ...rest }) {
+        const data = getEntityBody(type, {
+            name,
+            roles,
+            ...rest,
+        });
+        const params = {
+            kbId,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: `/kb/entities/${type}`,
+            data,
+            params,
+        });
+    }
+    async createFeature({ kbId, name, mode, words, enabledForAllModels }) {
+        const data = {
+            name,
+            mode,
+            words,
+            enabledForAllModels,
+        };
+        const params = {
+            kbId,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/phraselists',
+            data,
+            params,
+        });
+    }
+    async updateApplication({ kbId, id, name, desc, model_features }) {
+        const data = {
+            kbId,
+            id,
+            name,
+            desc,
+            model_features,
+        };
+        return this.callApi({
+            method: 'PUT',
+            route: '/applications',
+            data: data,
+        });
+    }
+    async updateIntent({ name, type, id, appId, kbId, postprocessFlows, customData, features }) {
+        const data = {
+            name,
+            type,
+            postprocessFlows,
+            customData,
+            features,
+        };
+        const params = {
+            id,
+            kbId,
+            appId,
+        };
+        return this.callApi({
+            method: 'PUT',
+            route: '/intents',
+            data,
+            params,
+        });
+    }
+    async updateUtterance({ appId, kbId, utterance }) {
+        const params = {
+            kbId,
+            appId,
+        };
+        return this.callApi({
+            method: 'PUT',
+            route: '/utterances',
+            data: utterance,
+            params,
+        });
+    }
+    async updatePattern({ appId, kbId, pattern }) {
+        const params = {
+            kbId,
+            appId,
+        };
+        return this.callApi({
+            method: 'PUT',
+            route: '/patterns',
+            data: pattern,
+            params,
+        });
+    }
+    async updatePair({ kbId, applicationName, intentName, intentType, utterance }) {
+        const data = {
+            kbId,
+            applicationName,
+            intentName,
+            intentType,
+            utterance,
+        };
+        await this.callApi({
+            method: 'PUT',
+            route: '/knowledge-base/pair',
+            data,
+        });
+    }
+    async batchUpdatePairs({ kbId, utterances }) {
+        const params = {
+            kbId,
+        };
+        return this.callApi({
+            method: 'PUT',
+            route: '/knowledge-base/pairs',
+            data: utterances,
+            params,
+        });
+    }
+    async updateEntity({ type, id, kbId, name, roles, ...rest }) {
+        const data = getEntityBody(type, {
+            name,
+            roles,
+            ...rest,
+        });
+        const params = {
+            id,
+            kbId,
+        };
+        return this.callApi({
+            method: 'PUT',
+            route: `/kb/entities/${type}`,
+            data,
+            params,
+        });
+    }
+    async updateFeature({ kbId, id, name, mode, words, enabledForAllModels, activated = true }) {
+        const data = {
+            name,
+            mode,
+            words,
+            enabledForAllModels,
+            activated,
+        };
+        const params = {
+            id,
+            kbId,
+        };
+        return this.callApi({
+            method: 'PUT',
+            route: '/phraselists',
+            data,
+            params,
+        });
+    }
+    async updatePrebuiltEntities({ kbId, id, entity }) {
+        const params = {
+            kbId,
+            id,
+        };
+        return this.callApi({
+            method: 'PUT',
+            route: '/kb/entities/prebuilt',
+            data: entity,
+            params,
+        });
+    }
+    async deleteKnowledgeBase({ id }) {
+        const params = {
+            id,
+        };
+        await this.callApi({
+            method: 'DELETE',
+            route: '/knowledge-base',
+            params,
+        });
+    }
+    async deleteApplication({ kbId, appId }) {
+        const params = {
+            kbId,
+            appId,
+        };
+        await this.callApi({
+            method: 'DELETE',
+            route: '/applications',
+            params,
+        });
+    }
+    async deleteIntent({ id, appId, kbId }) {
+        const params = {
+            id,
+            kbId,
+            appId,
+            deleteUtterances: true,
+        };
+        await this.callApi({
+            method: 'DELETE',
+            route: '/intents',
+            params,
+        });
+    }
+    async deleteUtterance({ id, kbId }) {
+        const params = {
+            id,
+            kbId,
+        };
+        await this.callApi({
+            method: 'DELETE',
+            route: '/utterances',
+            params,
+        });
+    }
+    async batchDeleteUtterances({ ids, kbId }) {
+        const params = {
+            kbId,
+        };
+        await this.callApi({
+            method: 'POST',
+            route: '/utterances/bulk/delete',
+            params,
+            data: ids,
+        });
+    }
+    async deletePattern({ id, kbId }) {
+        const params = {
+            id,
+            kbId,
+        };
+        await this.callApi({
+            method: 'DELETE',
+            route: '/patterns',
+            params,
+        });
+    }
+    async deleteEntity({ type, id, kbId }) {
+        const params = {
+            id,
+            kbId,
+        };
+        await this.callApi({
+            method: 'DELETE',
+            route: `/kb/entities/${type}`,
+            params,
+        });
+    }
+    async deleteFeature({ id, kbId }) {
+        const params = {
+            id,
+            kbId,
+        };
+        await this.callApi({
+            method: 'DELETE',
+            route: '/phraselists',
+            params,
+        });
+    }
+    async getTrainStatus({ kbId, versionId = null }) {
+        const params = {
+            kbId,
+            versionId,
+        };
+        return this.callApi({
+            method: 'GET',
+            route: '/train/status',
+            params,
+        });
+    }
+    async train({ kbId, flowId, phraseId, sessionId, autoPublish }) {
+        const params = {
+            kbId,
+            flowId,
+            phraseId,
+            sessionId,
+            autoPublish,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/kb/train',
+            params,
+            data: null,
+        });
+    }
+    async trainForTest({ kbId, flowId, phraseId, sessionId }) {
+        const params = {
+            kbId,
+            flowId,
+            phraseId,
+            sessionId,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/kb/train/test',
+            params,
+            data: null,
+        });
+    }
+    async publish({ kbId, versionId = null }) {
+        const params = {
+            kbId,
+            versionId,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/kb/publish',
+            params,
+            data: null,
+        });
+    }
+    async recover({ kbId, versionId }) {
+        const params = {
+            kbId,
+            versionId,
+        };
+        await this.callApi({
+            method: 'POST',
+            route: '/kb/recover',
+            params,
+            data: null,
+        });
+    }
+    async deleteVersion({ kbId, versionId }) {
+        const params = {
+            kbId,
+            versionId,
+        };
+        await this.callApi({
+            method: 'DELETE',
+            route: '/kb/versions',
+            params,
+        });
+    }
+    async clone({ kbId, newName }) {
+        const data = {
+            newName,
+        };
+        const params = {
+            id: kbId,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/knowledge-base/clone',
+            params,
+            data,
+        });
+    }
+    async export({ kbId, isPublic }) {
+        const params = {
+            id: kbId,
+            isPublic,
+        };
+        return this.callApi({
+            method: 'GET',
+            route: '/knowledge-base/export',
+            params,
+        });
+    }
+    async import({ fileUrl, knowledgeBase }) {
+        const data = {
+            fileUrl,
+            knowledgeBase,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/knowledge-base/import',
+            data,
+        });
+    }
+    async importJson(data) {
+        return this.callApi({
+            method: 'POST',
+            route: '/knowledge-base/import/json',
+            data,
+        });
+    }
+    async importCsv({ fileUrl, knowledgeBase, applicationName, delimiter }) {
+        const data = {
+            fileUrl,
+            knowledgeBase,
+            applicationName,
+            delimiter,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/knowledge-base/import/csv',
+            data,
+        });
+    }
+    async meaning(data) {
+        return this.callApi({
+            method: 'POST',
+            route: '/meaning',
+            data,
+        });
+    }
+    async testMeaning({ q, appId, kbId }) {
+        const data = {
+            q,
+            appId,
+            kbId,
+        };
+        return this.callApi({
+            method: 'POST',
+            route: '/meaning/test',
+            data,
         });
     }
 }