@or-sdk/knowledge-models 0.12.0

package/dist/esm/KnowledgeModels.js

@@ -0,0 +1,860 @@
+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';
+export class KnowledgeModels extends Base {
+    constructor(params) {
+        const { token, discoveryUrl } = params;
+        super({
+            token,
+            discoveryUrl,
+            serviceKey: SERVICE_KEY,
+        });
+    }
+    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.rows.find(km => km.id === id);
+        });
+    }
+    createKnowledgeModel({ name, desc, imageSrc, config, culture, extensions }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                name,
+                desc,
+                imageSrc,
+                culture,
+                config,
+                extensions,
+            };
+            return this.callApi({
+                method: 'POST',
+                route: '/knowledge-base',
+                params,
+            });
+        });
+    }
+    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,
+            });
+        });
+    }
+}
+//# sourceMappingURL=KnowledgeModels.js.map