@or-sdk/knowledge-models 0.25.0-beta.647.0 → 0.25.0

package/dist/esm/KnowledgeModels.js

@@ -1,6 +1,26 @@
+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';
+import { getEntityBody } from './utils';
 export class KnowledgeModels extends Base {
     constructor(params) {
         const { token, discoveryUrl, nluUrl } = params;
@@ -11,723 +31,830 @@ export class KnowledgeModels extends Base {
             serviceUrl: nluUrl,
         });
     }
-    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,
+    getFullList(method_1, route_1) {
+        return __awaiter(this, arguments, void 0, function* (method, route, queryParams = {}) {
+            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(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ name, desc, imageSrc, config, culture, extensions, }) {
+            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(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ accountId, limits, }) {
+            const data = {
+                accountId,
+                limits,
+            };
+            yield this.callApi({
+                method: 'POST',
+                route: '/administration/limits',
+                data,
+            });
+        });
+    }
+    listPrebuiltEntities() {
+        return __awaiter(this, arguments, void 0, function* ({ language } = {}) {
+            const params = {
+                language,
+            };
+            const result = yield this.callApi({
+                method: 'GET',
+                route: '/kb/entities/prebuilt/all',
+                params,
+            });
+            return makeList(result);
+        });
+    }
+    listEntities(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ type, kbId, versionId, limit, }) {
+            const params = {
+                kbId,
+                versionId,
+                limit,
+            };
+            return this.getFullList('GET', `/kb/entities/${type}`, params);
+        });
+    }
+    listFeatures(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, versionId, limit, }) {
+            const params = {
+                kbId,
+                versionId,
+                limit,
+            };
+            return this.getFullList('GET', '/phraselists', params);
+        });
+    }
+    listApplications(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, text, pattern, versionId, limit, projection, }) {
+            const params = {
+                kbId,
+                limit,
+                text,
+                pattern,
+                versionId,
+                projection,
+            };
+            return this.getFullList('GET', '/applications', params);
+        });
+    }
+    listIntentsLabels(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ appId, kbId }) {
+            const params = {
+                appId,
+                kbId,
+            };
+            return this.callApi({
+                method: 'GET',
+                route: '/intents/labels',
+                params,
+            });
+        });
+    }
+    listUtterances(_a) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var { kbId, limit } = _a, query = __rest(_a, ["kbId", "limit"]);
+            const params = Object.assign({ kbId,
+                limit }, query);
+            return this.getFullList('GET', '/utterances', params);
+        });
+    }
+    listPatterns(_a) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var { kbId, limit } = _a, query = __rest(_a, ["kbId", "limit"]);
+            const params = Object.assign({ kbId,
+                limit }, query);
+            return this.getFullList('GET', '/patterns', params);
+        });
+    }
+    listPrebuiltModels() {
+        return __awaiter(this, arguments, void 0, function* (_a = {}) {
+            var { limit } = _a, query = __rest(_a, ["limit"]);
+            const params = Object.assign({ limit }, query);
+            return this.getFullList('GET', '/prebuilt-models', params);
+        });
+    }
+    removePrebuiltModelFromKM(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ prebuiltModelId, kbId, }) {
+            const params = {
+                prebuiltModelId,
+                kbId,
+            };
+            yield this.callApi({
+                method: 'DELETE',
+                route: '/knowledge-base/prebuilt-model',
+                params,
+            });
+        });
+    }
+    addPrebuiltModelToKM(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ 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,
+            });
+        });
+    }
+    getPrebuiltModelDetails(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, prebuiltModelId, }) {
+            const params = {
+                kbId,
+                prebuiltModelId,
+            };
+            return this.callApi({
+                method: 'GET',
+                route: '/knowledge-base/prebuilt-model',
+                params,
+            });
+        });
+    }
+    createApplication(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, name, desc, culture, model_features, }) {
+            const data = {
+                kbId,
+                name,
+                desc,
+                culture,
+                model_features,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/applications',
+                data,
+            });
+        });
+    }
+    createIntent(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ 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,
+            });
+        });
+    }
+    createUtterance(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ 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,
+            });
+        });
+    }
+    createPattern(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ appId, kbId, pattern, intent, entities, }) {
+            const data = {
+                pattern,
+                intent,
+                entities,
+            };
+            const params = {
+                kbId,
+                appId,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/patterns',
+                data,
+                params,
+            });
+        });
+    }
+    createPair(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, applicationName, intentName, intentType, utteranceText, }) {
+            const data = {
+                kbId,
+                applicationName,
+                intentName,
+                intentType,
+                utteranceText,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/knowledge-base/pair',
+                data,
+            });
+        });
+    }
+    batchCreatePairs(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, utterances, }) {
+            const data = {
+                kbId,
+                utterances,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/knowledge-base/pairs',
+                data,
+            });
+        });
+    }
+    batchCreatePairsFile(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, fileUrl, }) {
+            const data = {
+                kbId,
+                fileUrl,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/knowledge-base/pairs/file',
+                data,
+            });
+        });
+    }
+    createPatternPair(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ 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,
+            });
+        });
+    }
+    createPairsCsv(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, fileUrl, applicationName, delimiter, }) {
+            const data = {
+                kbId,
+                applicationName,
+                fileUrl,
+                delimiter,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/knowledge-base/pair/csv',
+                data,
+            });
+        });
+    }
+    createEntity(_a) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var { type, kbId, name, roles } = _a, rest = __rest(_a, ["type", "kbId", "name", "roles"]);
+            const data = getEntityBody(type, Object.assign({ name,
+                roles }, rest));
+            const params = {
+                kbId,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: `/kb/entities/${type}`,
+                data,
+                params,
+            });
+        });
+    }
+    createFeature(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, name, mode, words, enabledForAllModels, }) {
+            const data = {
+                name,
+                mode,
+                words,
+                enabledForAllModels,
+            };
+            const params = {
+                kbId,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/phraselists',
+                data,
+                params,
+            });
+        });
+    }
+    updateApplication(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, id, name, desc, model_features, }) {
+            const data = {
+                kbId,
+                id,
+                name,
+                desc,
+                model_features,
+            };
+            return this.callApi({
+                method: 'PUT',
+                route: '/applications',
+                data: data,
+            });
+        });
+    }
+    updateIntent(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ 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,
+            });
+        });
+    }
+    updateUtterance(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ appId, kbId, utterance, }) {
+            const params = {
+                kbId,
+                appId,
+            };
+            return this.callApi({
+                method: 'PUT',
+                route: '/utterances',
+                data: utterance,
+                params,
+            });
+        });
+    }
+    updatePattern(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ appId, kbId, pattern, }) {
+            const params = {
+                kbId,
+                appId,
+            };
+            return this.callApi({
+                method: 'PUT',
+                route: '/patterns',
+                data: pattern,
+                params,
+            });
+        });
+    }
+    updatePair(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, applicationName, intentName, intentType, utterance, }) {
+            const data = {
+                kbId,
+                applicationName,
+                intentName,
+                intentType,
+                utterance,
+            };
+            yield this.callApi({
+                method: 'PUT',
+                route: '/knowledge-base/pair',
+                data,
+            });
+        });
+    }
+    batchUpdatePairs(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, utterances, }) {
+            const params = {
+                kbId,
+            };
+            return this.callApi({
+                method: 'PUT',
+                route: '/knowledge-base/pairs',
+                data: utterances,
+                params,
+            });
+        });
+    }
+    updateEntity(_a) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var { type, id, kbId, name, roles } = _a, rest = __rest(_a, ["type", "id", "kbId", "name", "roles"]);
+            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(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ 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,
+            });
+        });
+    }
+    updatePrebuiltEntities(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, id, entity, }) {
+            const params = {
+                kbId,
+                id,
+            };
+            return this.callApi({
+                method: 'PUT',
+                route: '/kb/entities/prebuilt',
+                data: entity,
+                params,
+            });
+        });
+    }
+    deleteKnowledgeBase(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            const params = {
+                id,
+            };
+            yield this.callApi({
+                method: 'DELETE',
+                route: '/knowledge-base',
+                params,
+            });
+        });
+    }
+    deleteApplication(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, appId }) {
+            const params = {
+                kbId,
+                appId,
+            };
+            yield this.callApi({
+                method: 'DELETE',
+                route: '/applications',
+                params,
+            });
+        });
+    }
+    deleteIntent(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id, appId, kbId }) {
+            const params = {
+                id,
+                kbId,
+                appId,
+                deleteUtterances: true,
+            };
+            yield this.callApi({
+                method: 'DELETE',
+                route: '/intents',
+                params,
+            });
+        });
+    }
+    deleteUtterance(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id, kbId }) {
+            const params = {
+                id,
+                kbId,
+            };
+            yield this.callApi({
+                method: 'DELETE',
+                route: '/utterances',
+                params,
+            });
+        });
+    }
+    batchDeleteUtterances(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ ids, kbId }) {
+            const params = {
+                kbId,
+            };
+            yield this.callApi({
+                method: 'POST',
+                route: '/utterances/bulk/delete',
+                params,
+                data: ids,
+            });
+        });
+    }
+    deletePattern(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id, kbId }) {
+            const params = {
+                id,
+                kbId,
+            };
+            yield this.callApi({
+                method: 'DELETE',
+                route: '/patterns',
+                params,
+            });
+        });
+    }
+    deleteEntity(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ type, id, kbId }) {
+            const params = {
+                id,
+                kbId,
+            };
+            yield this.callApi({
+                method: 'DELETE',
+                route: `/kb/entities/${type}`,
+                params,
+            });
+        });
+    }
+    deleteFeature(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id, kbId }) {
+            const params = {
+                id,
+                kbId,
+            };
+            yield this.callApi({
+                method: 'DELETE',
+                route: '/phraselists',
+                params,
+            });
+        });
+    }
+    getTrainStatus(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, versionId = null, }) {
+            const params = {
+                kbId,
+                versionId,
+            };
+            return this.callApi({
+                method: 'GET',
+                route: '/train/status',
+                params,
+            });
+        });
+    }
+    train(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, flowId, phraseId, sessionId, autoPublish, }) {
+            const params = {
+                kbId,
+                flowId,
+                phraseId,
+                sessionId,
+                autoPublish,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/kb/train',
+                params,
+                data: null,
+            });
+        });
+    }
+    trainForTest(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, flowId, phraseId, sessionId, }) {
+            const params = {
+                kbId,
+                flowId,
+                phraseId,
+                sessionId,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/kb/train/test',
+                params,
+                data: null,
+            });
+        });
+    }
+    publish(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, versionId = null, }) {
+            const params = {
+                kbId,
+                versionId,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/kb/publish',
+                params,
+                data: null,
+            });
+        });
+    }
+    recover(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, versionId }) {
+            const params = {
+                kbId,
+                versionId,
+            };
+            yield this.callApi({
+                method: 'POST',
+                route: '/kb/recover',
+                params,
+                data: null,
+            });
+        });
+    }
+    deleteVersion(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, versionId }) {
+            const params = {
+                kbId,
+                versionId,
+            };
+            yield this.callApi({
+                method: 'DELETE',
+                route: '/kb/versions',
+                params,
+            });
+        });
+    }
+    clone(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, newName }) {
+            const data = {
+                newName,
+            };
+            const params = {
+                id: kbId,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/knowledge-base/clone',
+                params,
+                data,
+            });
+        });
+    }
+    export(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ kbId, isPublic }) {
+            const params = {
+                id: kbId,
+                isPublic,
+            };
+            return this.callApi({
+                method: 'GET',
+                route: '/knowledge-base/export',
+                params,
+            });
+        });
+    }
+    import(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ fileUrl, knowledgeBase, }) {
+            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(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ fileUrl, knowledgeBase, applicationName, delimiter, }) {
+            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(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ q, appId, kbId }) {
+            const data = {
+                q,
+                appId,
+                kbId,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/meaning/test',
+                data,
+            });
         });
     }
 }