@or-sdk/knowledge-models 0.12.0

package/src/KnowledgeModels.ts

@@ -0,0 +1,1302 @@
+import { Base, List, makeList, CalApiParams } from '@or-sdk/base';
+import {
+  KnowledgeModelsConfig,
+  KnowledgeModel,
+  KnowledgeModelOptionalFields,
+  PartialListResponse,
+  KnowledgeModelCreateParams,
+  LimitsResponse,
+  Entity,
+  PrebuiltEntity,
+  Feature,
+  Application,
+  IntentLabelsResponse,
+  Utterance,
+  Pattern,
+  PrebuiltModel,
+  PrebuiltModelDetails,
+  Intent,
+  UtteranceEntity,
+  PatternEntity,
+  Pair,
+  CreatePairsResponse,
+  UpdatedPairsResponse,
+  TrainStatusResponse,
+  TrainResponse,
+  PublishResponse,
+  ImportResponse,
+  MeaningResponse,
+  CloneResponse,
+} from './types';
+import { getEntityBody } from './utils';
+import { SERVICE_KEY } from './constants';
+
+/**
+ * OneReach KnowledgeModels service client
+ *  ## Installation:
+ * ```
+ * $ npm i @or-sdk/knowledge-models
+ * ```
+ */
+export class KnowledgeModels extends Base {
+  /**
+   * ```typescript
+   * import { KnowledgeModels } from '@or-sdk/knowledge-models'
+   * const knowledgeModels = new KnowledgeModels({token: 'my-account-token-string', discoveryUrl: 'http://example.nlu/endpoint'});
+   * ```
+   */
+  constructor(params: KnowledgeModelsConfig) {
+    const { token, discoveryUrl } = params;
+
+    super({
+      token,
+      discoveryUrl,
+      serviceKey: SERVICE_KEY,
+    });
+  }
+
+  private async getFullList<T>(method: CalApiParams['method'], route: string, queryParams: { [key: string]: unknown; } = {}): Promise<List<T>> {
+    const params = {
+      ...queryParams,
+      last: undefined as unknown,
+    };
+
+    let result: PartialListResponse<T>;
+    let list: T[] = [];
+
+    do {
+      result = await this.callApi<PartialListResponse<T>>({
+        method,
+        route,
+        params,
+      });
+
+      list = [...list, ...result.items];
+      params.last = result.last;
+
+    } while (result.last && result.items.length);
+
+    return makeList<T>(list);
+  }
+
+  /**
+   * List knowledge models
+   * ```typescript
+   * const knowledgeModels = await knowledgeModels.listKnowledgeModels();
+   * ```
+   */
+  public async listKnowledgeModels(): Promise<List<KnowledgeModel>> {
+    return this.getFullList<KnowledgeModel>('GET', '/knowledge-base');
+  }
+
+  /**
+   * Get knowledge model
+   * ```typescript
+   * const knowledgeModel = await knowledgeModels.getKnowledgeModel('km-id');
+   * ```
+   */
+  public async getKnowledgeModel(id: string): Promise<KnowledgeModel> {
+    const list = await this.listKnowledgeModels();
+
+    return list.rows.find(km => km.id === id) as KnowledgeModel;
+  }
+
+  /**
+   * Create knowledge model
+   * ```typescript
+   * const knowledgeModel = await knowledgeModels.createKnowledgeModel({
+   *  name: 'km_name',
+   *  desc: 'km_desc',
+   *  imageSrc: 'http://img.png',
+   *  config: {},
+   *  culture: 'en-us',
+   *  extensions: ['luis']
+   * });
+   * ```
+   */
+  public async createKnowledgeModel({ name, desc, imageSrc, config, culture, extensions }: KnowledgeModelCreateParams): Promise<KnowledgeModel> {
+    const params = {
+      name,
+      desc,
+      imageSrc,
+      culture,
+      config,
+      extensions,
+    };
+
+    return this.callApi<KnowledgeModel>({
+      method: 'POST',
+      route: '/knowledge-base',
+      params,
+    });
+  }
+
+  /**
+   * Update knowledge model
+   * ```typescript
+   * const knowledgeModel = await knowledgeModels.updateKnowledgeModel({ id: 'km-id', name: 'updated_name' });
+   * ```
+   */
+  public async updateKnowledgeModel(knowledgeModel: KnowledgeModelOptionalFields): Promise<KnowledgeModel> {
+    return this.callApi<KnowledgeModel>({
+      method: 'PUT',
+      route: '/knowledge-base',
+      data: knowledgeModel,
+    });
+  }
+
+  /**
+   * Get limits index
+   * ```typescript
+   * const result = await knowledgeModels.getLimitsIndex();
+   * ```
+   */
+  public async getLimitsIndex(): Promise<LimitsResponse> {
+    return this.callApi<LimitsResponse>({
+      method: 'GET',
+      route: '/administration/limits/index',
+    });
+  }
+
+  /**
+   * Get limits
+   * ```typescript
+   * const result = await knowledgeModels.getLimits('limits-path');
+   * ```
+   */
+  public async getLimits(path: string): Promise<number> {
+    const params = {
+      path,
+    };
+
+    return this.callApi<number>({
+      method: 'GET',
+      route: '/administration/limits',
+      params,
+    });
+  }
+
+  /**
+   * Post limits
+   * ```typescript
+   * const result = await knowledgeModels.postLimits({ accountId: 'acc-id', limits: { metric: '', number: 0 } });
+   * ```
+   */
+  public async postLimits({ accountId, limits }: { accountId: string; limits: { metric: string; number: number; }; }): Promise<void> {
+    const data = {
+      accountId,
+      limits,
+    };
+
+    await this.callApi<void>({
+      method: 'POST',
+      route: '/administration/limits',
+      data,
+    });
+  }
+
+  /**
+   * List prebuilt entities
+   * ```typescript
+   * const result = await knowledgeModels.listPrebuiltEntities({ language: 'lang' });
+   * ```
+   */
+  public async listPrebuiltEntities({ language }: { language?: string; } = {}): Promise<List<PrebuiltEntity>> {
+    const params = {
+      language,
+    };
+
+    const result = await this.callApi<PrebuiltEntity[]>({
+      method: 'GET',
+      route: '/kb/entities/prebuilt/all',
+      params,
+    });
+
+    return makeList<PrebuiltEntity>(result);
+  }
+
+  /**
+   * List entities
+   * ```typescript
+   * const result = await knowledgeModels.listEntities({ type: 'type', kbId: 'kb-id', versionId: 'version-id', limit: 30 });
+   * ```
+   */
+  public async listEntities({ type, kbId, versionId, limit }: { type: string; kbId?: string; versionId?: string; limit?: number; }): Promise<List<Entity>> {
+    const params = {
+      kbId,
+      versionId,
+      limit,
+    };
+
+    return this.getFullList<Entity>('GET', `/kb/entities/${type}`, params);
+  }
+
+  /**
+   * List features
+   * ```typescript
+   * const result = await knowledgeModels.listFeatures({ type: 'type', kbId: 'kb-id', versionId: 'version-id', limit: 30 });
+   * ```
+   */
+  public async listFeatures({ kbId, versionId, limit }: { kbId: string; versionId?: string; limit?: number; }): Promise<List<Feature>> {
+    const params = {
+      kbId,
+      versionId,
+      limit,
+    };
+
+    return this.getFullList<Feature>('GET', '/phraselists', params);
+  }
+
+  /**
+   * List applications
+   * ```typescript
+   * const result = await knowledgeModels.listApplications({ kbId: 'kb-id', text: 'text', pattern: 'pattern', versionId: 'version-id', limit: 30, projection: ['fieldName'] });
+   * ```
+   */
+  public async listApplications({ kbId, text, pattern, versionId, limit, projection }: { kbId: string; text?: string; pattern?: string; versionId?: string; limit?: number; projection?: string[]; }): Promise<List<Application>> {
+    const params = {
+      kbId,
+      limit,
+      text,
+      pattern,
+      versionId,
+      projection,
+    };
+
+    return this.getFullList<Application>('GET', '/applications', params);
+  }
+
+  /**
+   * List intents labels
+   * ```typescript
+   * const result = await knowledgeModels.listIntentsLabels({ appId: 'app-id', kbId: 'kb-id' });
+   * ```
+   */
+  public async listIntentsLabels({ appId, kbId }: { appId: string; kbId: string; }): Promise<IntentLabelsResponse> {
+    const params = {
+      appId,
+      kbId,
+    };
+
+    return this.callApi<IntentLabelsResponse>({
+      method: 'GET',
+      route: '/intents/labels',
+      params,
+    });
+  }
+
+  /**
+   * List utterances
+   * ```typescript
+   * const result = await knowledgeModels.listUtterances({ kbId: 'kb-id', limit: 30 });
+   * ```
+   */
+  public async listUtterances({ kbId, limit, ...query }: { kbId: string; limit?: number; query?: { [key: string]: unknown; }; }): Promise<List<Utterance>> {
+    const params = {
+      kbId,
+      limit,
+      ...query,
+    };
+
+    return this.getFullList<Utterance>('GET', '/utterances', params);
+  }
+
+  /**
+   * List patterns
+   * ```typescript
+   * const result = await knowledgeModels.listPatterns({ kbId: 'kb-id', limit: 30 });
+   * ```
+   */
+  public async listPatterns({ kbId, limit, ...query }: { kbId: string; limit?: number; query?: { [key: string]: unknown; }; }): Promise<List<Pattern>> {
+    const params = {
+      kbId,
+      limit,
+      ...query,
+    };
+
+    return this.getFullList<Pattern>('GET', '/patterns', params);
+  }
+
+  /**
+   * List prebuilt models
+   * ```typescript
+   * const result = await knowledgeModels.listPrebuiltModels({ limit: 30 });
+   * ```
+   */
+  public async listPrebuiltModels({ limit, ...query }: { limit?: number; query?: { [key: string]: unknown; }; } = {}): Promise<List<PrebuiltModel>> {
+    const params = {
+      limit,
+      ...query,
+    };
+
+    return this.getFullList<PrebuiltModel>('GET', '/prebuilt-models', params);
+  }
+
+  /**
+   * Remove prebuilt model from knowledge model
+   * ```typescript
+   * await knowledgeModels.listPrebuiltModels({ prebuiltModelId: 'prebuilt-model-id', kbId: 'kb-id' });
+   * ```
+   */
+  public async removePrebuiltModelFromKM({ prebuiltModelId, kbId }: { prebuiltModelId: string; kbId: string; }): Promise<void> {
+    const params = {
+      prebuiltModelId,
+      kbId,
+    };
+
+    await this.callApi({
+      method: 'DELETE',
+      route: '/knowledge-base/prebuilt-model',
+      params,
+    });
+  }
+
+  /**
+   * Add prebuilt model to knowledge model
+   * ```typescript
+   * const result = await knowledgeModels.addPrebuiltModelToKM({
+   *  kbId: 'kb-id',
+   *  prebuiltModelId: 'prebuilt-model-id',
+   *  appId: 'app-id',
+   *  appName: 'App Name',
+   *  shouldCreateNewApplication: false,
+   *  responses: ['response'],
+   *  entities: ['entity name'],
+   * });
+   * ```
+   */
+  public async addPrebuiltModelToKM({
+    kbId,
+    prebuiltModelId,
+    appId,
+    appName,
+    shouldCreateNewApplication,
+    responses,
+    entities,
+  }: {
+    kbId: string;
+    prebuiltModelId: string;
+    appId: string;
+    appName: string;
+    shouldCreateNewApplication: boolean;
+    responses: string[];
+    entities: string[];
+  }): Promise<Application> {
+    const data = {
+      kbId,
+      appId,
+      prebuiltModelId,
+      appName,
+      shouldCreateNewApplication,
+      responses,
+      entities,
+    };
+
+    return this.callApi<Application>({
+      method: 'POST',
+      route: '/knowledge-base/prebuilt-model',
+      data,
+    });
+  }
+
+  /**
+   * Get prebuilt models details
+   * ```typescript
+   * const result = await knowledgeModels.getPrebuiltModelDetails({ kbId: 'kb-id', prebuiltModelId: 'prebuilt-model-id' });
+   * ```
+   */
+  public async getPrebuiltModelDetails({ kbId, prebuiltModelId }: { kbId: string; prebuiltModelId: string; }): Promise<PrebuiltModelDetails> {
+    const params = {
+      kbId,
+      prebuiltModelId,
+    };
+
+    return this.callApi<PrebuiltModelDetails>({
+      method: 'GET',
+      route: '/knowledge-base/prebuilt-model',
+      params,
+    });
+  }
+
+  /**
+   * Create application
+   * ```typescript
+   * const result = await knowledgeModels.createApplication({ kbId: 'kb-id', name: 'Name', desc: 'Description', culture: 'en-us', model_features: ['feat-id'] });
+   * ```
+   */
+  public async createApplication({ kbId, name, desc, culture, model_features }: { kbId: string; name: string; desc: string; culture: string; model_features: string[]; }): Promise<Application> {
+    const data = {
+      kbId,
+      name,
+      desc,
+      culture,
+      model_features,
+    };
+
+    return this.callApi<Application>({
+      method: 'POST',
+      route: '/applications',
+      data,
+    });
+  }
+
+  /**
+   * Create intent
+   * ```typescript
+   * const result = await knowledgeModels.createIntent({ name: 'Name', type: 'type', kbId: 'kb-id', appId: 'app-id', postprocessFlows: ['flows-id'], customData: {}, features: ['feat-id']});
+   * ```
+   */
+  public async createIntent({ name, type, kbId, appId, postprocessFlows, customData, features }: { name: string; type: string; kbId: string; appId: string; postprocessFlows: string[]; customData?: { [key: string]: unknown; }; features: string[]; }): Promise<Intent> {
+    const data = {
+      name,
+      type,
+      postprocessFlows,
+      customData,
+      features,
+    };
+
+    const params = {
+      kbId,
+      appId,
+    };
+
+    return this.callApi<Intent>({
+      method: 'POST',
+      route: '/intents',
+      data,
+      params,
+    });
+  }
+
+  /**
+   * Create utterance
+   * ```typescript
+   * const result = await knowledgeModels.createUtterance({ appId: 'app-id', kbId: 'kb-id', autoGenerated: false, text: 'text', intent: 'intent-id', entities: [] });
+   * ```
+   */
+  public async createUtterance({ appId, kbId, autoGenerated, text, intent, entities }: { appId: string; kbId: string; autoGenerated?: boolean; text: string; intent: string; entities: UtteranceEntity[]; }): Promise<Utterance> {
+    const data = {
+      autoGenerated,
+      text,
+      intent,
+      entities,
+    };
+
+    const params = {
+      kbId,
+      appId,
+    };
+
+    return this.callApi<Utterance>({
+      method: 'POST',
+      route: '/utterances',
+      data,
+      params,
+    });
+  }
+
+  /**
+   * Create pattern
+   * ```typescript
+   * const result = await knowledgeModels.createPattern({ appId: 'app-id', kbId: 'kb-id', pattern: 'pattern', intent: 'intent-id', entities: [] });
+   * ```
+   */
+  public async createPattern({ appId, kbId, pattern, intent, entities }: { appId: string; kbId: string; pattern: string; intent: string; entities: PatternEntity[]; }): Promise<Pattern> {
+    const data = {
+      pattern,
+      intent,
+      entities,
+    };
+
+    const params = {
+      kbId,
+      appId,
+    };
+
+    return this.callApi<Pattern>({
+      method: 'POST',
+      route: '/patterns',
+      data,
+      params,
+    });
+  }
+
+  /**
+   * Create pair
+   * ```typescript
+   * const result = await knowledgeModels.createPair({ kbId: 'kb-id', applicationName: 'App name', intentName: 'Intent name', intentType: 'type', utteranceText: 'text' });
+   * ```
+   */
+  public async createPair({ kbId, applicationName, intentName, intentType, utteranceText }: { kbId: string; applicationName: string; intentName: string; intentType: string; utteranceText: string; }): Promise<Pair> {
+    const data = {
+      kbId,
+      applicationName,
+      intentName,
+      intentType,
+      utteranceText,
+    };
+
+    return this.callApi<Pair>({
+      method: 'POST',
+      route: '/knowledge-base/pair',
+      data,
+    });
+  }
+
+  /**
+   * Batch create pairs
+   * ```typescript
+   * const result = await knowledgeModels.batchCreatePairs({ kbId: 'kb-id', utterances: [] });
+   * ```
+   */
+  public async batchCreatePairs({ kbId, utterances }: { kbId: string; utterances: { text: string; intent: string; intentType: string; application: string; }[]; }): Promise<CreatePairsResponse> {
+    const data = {
+      kbId,
+      utterances,
+    };
+
+    return this.callApi<CreatePairsResponse>({
+      method: 'POST',
+      route: '/knowledge-base/pairs',
+      data,
+    });
+  }
+
+  /**
+   * Batch create pairs from file
+   * ```typescript
+   * const result = await knowledgeModels.batchCreatePairsFile({ kbId: 'kb-id', fileUrl: 'http://file.url' });
+   * ```
+   */
+  public async batchCreatePairsFile({ kbId, fileUrl }: { kbId: string; fileUrl: string; }): Promise<CreatePairsResponse> {
+    const data = {
+      kbId,
+      fileUrl,
+    };
+
+    return this.callApi<CreatePairsResponse>({
+      method: 'POST',
+      route: '/knowledge-base/pairs/file',
+      data,
+    });
+  }
+
+  /**
+   * Create pattern pair
+   * ```typescript
+   * const result = await knowledgeModels.createPatternPair({ kbId: 'kb-id', applicationName: 'App name', intentName: 'Intent name', intentType: 'type', patternText: 'text', patternEntities: [] });
+   * ```
+   */
+  public async createPatternPair({ kbId, applicationName, intentName, intentType, patternText, patternEntities }: { kbId: string; applicationName: string; intentName: string; intentType: string; patternText: string; patternEntities: PatternEntity[]; }): Promise<Pair> {
+    const data = {
+      kbId,
+      applicationName,
+      intentName,
+      intentType,
+      patternText,
+      patternEntities,
+    };
+
+    return this.callApi<Pair>({
+      method: 'POST',
+      route: '/knowledge-base/patterns/pair',
+      data,
+    });
+  }
+
+  /**
+   * Create pairs from csv
+   * ```typescript
+   * const result = await knowledgeModels.createPairsCsv({ kbId: 'kb-id', fileUrl: 'http://file.url', applicationName: 'App name', delimiter: 'delimiter' });
+   * ```
+   */
+  public async createPairsCsv({ kbId, fileUrl, applicationName, delimiter }: { kbId: string; fileUrl: string; applicationName: string; delimiter: string; }): Promise<CreatePairsResponse> {
+    const data = {
+      kbId,
+      applicationName,
+      fileUrl,
+      delimiter,
+    };
+
+    return this.callApi<CreatePairsResponse>({
+      method: 'POST',
+      route: '/knowledge-base/pair/csv',
+      data,
+    });
+  }
+
+  /**
+   * Create entity
+   * ```typescript
+   * const result = await knowledgeModels.createEntity({ type: 'type', kbId: 'kb-id', name: 'Name', roles: ['role'] });
+   * ```
+   */
+  public async createEntity({ type, kbId, name, roles, ...rest }: { type: string; kbId: string; name: string; roles: unknown[]; rest?: { [key: string]: unknown; }; }): Promise<Entity> {
+    const data = getEntityBody(type, {
+      name,
+      roles,
+      ...rest,
+    });
+
+    const params = {
+      kbId,
+    };
+
+    return this.callApi<Entity>({
+      method: 'POST',
+      route: `/kb/entities/${type}`,
+      data,
+      params,
+    });
+  }
+
+  /**
+   * Create feature
+   * ```typescript
+   * const result = await knowledgeModels.createFeature({ kbId: 'kb-id', name: 'Name', mode: false, words: ['word'], enabledForAllModels: true });
+   * ```
+   */
+  public async createFeature({ kbId, name, mode, words, enabledForAllModels }: { kbId: string; name: string; mode: boolean; words: string[]; enabledForAllModels: boolean; }): Promise<Feature> {
+    const data = {
+      name,
+      mode,
+      words,
+      enabledForAllModels,
+    };
+
+    const params = {
+      kbId,
+    };
+
+    return this.callApi<Feature>({
+      method: 'POST',
+      route: '/phraselists',
+      data,
+      params,
+    });
+  }
+
+  /**
+   * Update application
+   * ```typescript
+   * const result = await knowledgeModels.updateApplication({ kbId: 'kb-id', id: 'app-id', name: 'New name', desc: 'New desc', model_features: [] });
+   * ```
+   */
+  public async updateApplication({ kbId, id, name, desc, model_features }: { kbId: string; id: string; name?: string; desc?: string; model_features?: string[]; }): Promise<Application> {
+    const data = {
+      kbId,
+      id,
+      name,
+      desc,
+      model_features,
+    };
+
+    return this.callApi<Application>({
+      method: 'PUT',
+      route: '/applications',
+      data: data,
+    });
+  }
+
+  /**
+   * Update intent
+   * ```typescript
+   * const result = await knowledgeModels.updateIntent({ name: 'name', type: 'type', id: 'intent-id', appId: 'app-id', kbId: 'kb-id', postprocessFlows: [], customData: {}, features: [] });
+   * ```
+   */
+  public async updateIntent({ name, type, id, appId, kbId, postprocessFlows, customData, features }: { name?: string; type?: string; id: string; appId: string; kbId: string; postprocessFlows?: string[]; customData?: { [key: string]: unknown; }; features?: string[]; }): Promise<Intent> {
+    const data = {
+      name,
+      type,
+      postprocessFlows,
+      customData,
+      features,
+    };
+
+    const params = {
+      id,
+      kbId,
+      appId,
+    };
+
+    return this.callApi<Intent>({
+      method: 'PUT',
+      route: '/intents',
+      data,
+      params,
+    });
+  }
+
+  /**
+   * Update utterance
+   * ```typescript
+   * const result = await knowledgeModels.updateUtterance({ appId: 'app-id', kbId: 'kb-id', utterance });
+   * ```
+   */
+  public async updateUtterance({ appId, kbId, utterance }: { appId: string; kbId: string; utterance: Utterance; }): Promise<Utterance> {
+    const params = {
+      kbId,
+      appId,
+    };
+
+    return this.callApi<Utterance>({
+      method: 'PUT',
+      route: '/utterances',
+      data: utterance,
+      params,
+    });
+  }
+
+  /**
+   * Update pattern
+   * ```typescript
+   * const result = await knowledgeModels.updatePattern({ appId: 'app-id', kbId: 'kb-id', pattern });
+   * ```
+   */
+  public async updatePattern({ appId, kbId, pattern }: { appId: string; kbId: string; pattern: Pattern; }): Promise<Pattern> {
+    const params = {
+      kbId,
+      appId,
+    };
+
+    return this.callApi<Pattern>({
+      method: 'PUT',
+      route: '/patterns',
+      data: pattern,
+      params,
+    });
+  }
+
+  /**
+   * Update pair
+   * ```typescript
+   * const result = await knowledgeModels.updatePair({ kbId: 'kb-id', applicationName: 'appName', intentName: 'intName', intentType: 'type', utterance });
+   * ```
+   */
+  public async updatePair({ kbId, applicationName, intentName, intentType, utterance }: { kbId: string; applicationName: string; intentName: string; intentType: string; utterance: Utterance; }): Promise<void> {
+    const data = {
+      kbId,
+      applicationName,
+      intentName,
+      intentType,
+      utterance,
+    };
+
+    await this.callApi<void>({
+      method: 'PUT',
+      route: '/knowledge-base/pair',
+      data,
+    });
+  }
+
+  /**
+   * Batch update pairs
+   * ```typescript
+   * const result = await knowledgeModels.batchUpdatePairs({ kbId: 'kb-id', utterances: [utterance] });
+   * ```
+   */
+  public async batchUpdatePairs({ kbId, utterances }: { kbId: string; utterances: Utterance[]; }): Promise<UpdatedPairsResponse> {
+    const params = {
+      kbId,
+    };
+
+    return this.callApi<UpdatedPairsResponse>({
+      method: 'PUT',
+      route: '/knowledge-base/pairs',
+      data: utterances,
+      params,
+    });
+  }
+
+  /**
+   * Update entity
+   * ```typescript
+   * const result = await knowledgeModels.updateEntity({ type: 'type', id: 'id', kbId: 'kb-id', name: 'Name', roles: [] });
+   * ```
+   */
+  public async updateEntity({ type, id, kbId, name, roles, ...rest }: { type: string; id: string; kbId: string; name?: string; roles?: string[]; rest?: { [key: string]: unknown; }; }): Promise<Entity> {
+    const data = getEntityBody(type, {
+      name,
+      roles,
+      ...rest,
+    });
+
+    const params = {
+      id,
+      kbId,
+    };
+
+    return this.callApi<Entity>({
+      method: 'PUT',
+      route: `/kb/entities/${type}`,
+      data,
+      params,
+    });
+  }
+
+  /**
+   * Update feature
+   * ```typescript
+   * const result = await knowledgeModels.updateFeature({ kbId: 'kb-id', id: 'id', name: 'Name', mode: false, words: [], enabledForAllModels: true, activated: true });
+   * ```
+   */
+  public async updateFeature({ kbId, id, name, mode, words, enabledForAllModels, activated = true }: { kbId: string; id: string; name: string; mode: boolean; words: string[]; enabledForAllModels: boolean; activated: boolean; }): Promise<Feature> {
+    const data = {
+      name,
+      mode,
+      words,
+      enabledForAllModels,
+      activated,
+    };
+
+    const params = {
+      id,
+      kbId,
+    };
+
+    return this.callApi<Feature>({
+      method: 'PUT',
+      route: '/phraselists',
+      data,
+      params,
+    });
+  }
+
+  /**
+   * Update prebuilt entities
+   * ```typescript
+   * const result = await knowledgeModels.updatePrebuiltEntities({ kbId: 'kb-id', entity: { name: '', roles: [] } });
+   * ```
+   */
+  public async updatePrebuiltEntities({ kbId, id, entity }: { kbId: string; id: string; entity: { name: string; roles: string[]; }; }): Promise<Entity> {
+    const params = {
+      kbId,
+      id,
+    };
+
+    return this.callApi<Entity>({
+      method: 'PUT',
+      route: '/kb/entities/prebuilt',
+      data: entity,
+      params,
+    });
+  }
+
+  /**
+   * Delete knowledge base
+   * ```typescript
+   * await knowledgeModels.deleteKnowledgeBase({ id: 'id' });
+   * ```
+   */
+  public async deleteKnowledgeBase({ id }: { id: string; }): Promise<void> {
+    const params = {
+      id,
+    };
+
+    await this.callApi<void>({
+      method: 'DELETE',
+      route: '/knowledge-base',
+      params,
+    });
+  }
+
+  /**
+   * Delete application
+   * ```typescript
+   * await knowledgeModels.deleteApplication({ kbId: 'kb-id', appId: 'app-id' });
+   * ```
+   */
+  public async deleteApplication({ kbId, appId }: { kbId: string; appId: string; }): Promise<void> {
+    const params = {
+      kbId,
+      appId,
+    };
+
+    await this.callApi<void>({
+      method: 'DELETE',
+      route: '/applications',
+      params,
+    });
+  }
+
+  /**
+   * Delete intent
+   * ```typescript
+   * await knowledgeModels.deleteIntent({ id: 'id', kbId: 'kb-id', appId: 'app-id' });
+   * ```
+   */
+  public async deleteIntent({ id, appId, kbId }: { id: string; appId: string; kbId: string; }): Promise<void> {
+    const params = {
+      id,
+      kbId,
+      appId,
+      deleteUtterances: true,
+    };
+
+    await this.callApi<void>({
+      method: 'DELETE',
+      route: '/intents',
+      params,
+    });
+  }
+
+  /**
+   * Delete utterance
+   * ```typescript
+   * await knowledgeModels.deleteUtterance({ id: 'id', kbId: 'kb-id' });
+   * ```
+   */
+  public async deleteUtterance({ id, kbId }: { id: string; kbId: string; }): Promise<void> {
+    const params = {
+      id,
+      kbId,
+    };
+
+    await this.callApi<void>({
+      method: 'DELETE',
+      route: '/utterances',
+      params,
+    });
+  }
+
+  /**
+   * Batch delete utterances
+   * ```typescript
+   * await knowledgeModels.batchDeleteUtterances({ ids: ['id'], kbId: 'kb-id' });
+   * ```
+   */
+  public async batchDeleteUtterances({ ids, kbId }: { ids: string[]; kbId: string; }): Promise<void> {
+    const params = {
+      kbId,
+    };
+
+    await this.callApi<void>({
+      method: 'POST',
+      route: '/utterances/bulk/delete',
+      params,
+      data: ids,
+    });
+  }
+
+  /**
+   * Delete pattern
+   * ```typescript
+   * await knowledgeModels.deletePattern({ id: 'id', kbId: 'kb-id' });
+   * ```
+   */
+  public async deletePattern({ id, kbId }: { id: string; kbId: string; }): Promise<void> {
+    const params = {
+      id,
+      kbId,
+    };
+
+    await this.callApi<void>({
+      method: 'DELETE',
+      route: '/patterns',
+      params,
+    });
+  }
+
+  /**
+   * Delete entity
+   * ```typescript
+   * await knowledgeModels.deleteEntity({ type: 'type', id: 'id', kbId: 'kb-id' });
+   * ```
+   */
+  public async deleteEntity({ type, id, kbId }: { type: string; id: string; kbId: string; }): Promise<void> {
+    const params = {
+      id,
+      kbId,
+    };
+
+    await this.callApi<void>({
+      method: 'DELETE',
+      route: `/kb/entities/${type}`,
+      params,
+    });
+  }
+
+  /**
+   * Delete feature
+   * ```typescript
+   * await knowledgeModels.deleteFeature({ id: 'id', kbId: 'kb-id' });
+   * ```
+   */
+  public async deleteFeature({ id, kbId }: { id: string; kbId: string; }): Promise<void> {
+    const params = {
+      id,
+      kbId,
+    };
+
+    await this.callApi<void>({
+      method: 'DELETE',
+      route: '/phraselists',
+      params,
+    });
+  }
+
+  /**
+   * Get training status
+   * ```typescript
+   * const result = await knowledgeModels.getTrainStatus({ kbId: 'kb-id' });
+   * ```
+   */
+  public async getTrainStatus({ kbId, versionId = null }: { kbId: string; versionId: string | null; }): Promise<TrainStatusResponse> {
+    const params = {
+      kbId,
+      versionId,
+    };
+
+    return this.callApi<TrainStatusResponse>({
+      method: 'GET',
+      route: '/train/status',
+      params,
+    });
+  }
+
+  /**
+   * Start training
+   * ```typescript
+   * const result = await knowledgeModels.train({ kbId: 'kb-id', flowId: 'flow-id', phraseId: 'phrase-id', sessionId: 'session-id', autoPublish: true });
+   * ```
+   */
+  public async train({ kbId, flowId, phraseId, sessionId, autoPublish }: { kbId: string; flowId?: string; phraseId?: string; sessionId?: string; autoPublish: boolean; }): Promise<TrainResponse> {
+    const params = {
+      kbId,
+      flowId,
+      phraseId,
+      sessionId,
+      autoPublish,
+    };
+
+    return this.callApi<TrainResponse>({
+      method: 'POST',
+      route: '/kb/train',
+      params,
+      data: null,
+    });
+  }
+
+  /**
+   * Start training for test
+   * ```typescript
+   * const result = await knowledgeModels.trainForTest({ kbId: 'kb-id', flowId: 'flow-id', phraseId: 'phrase-id', sessionId: 'session-id' });
+   * ```
+   */
+  public async trainForTest({ kbId, flowId, phraseId, sessionId }: { kbId: string; flowId?: string; phraseId?: string; sessionId?: string; }): Promise<TrainResponse> {
+    const params = {
+      kbId,
+      flowId,
+      phraseId,
+      sessionId,
+    };
+
+    return this.callApi<TrainResponse>({
+      method: 'POST',
+      route: '/kb/train/test',
+      params,
+      data: null,
+    });
+  }
+
+  /**
+   * Publish knowledge model
+   * ```typescript
+   * const result = await knowledgeModels.publish({ kbId: 'kb-id' });
+   * ```
+   */
+  public async publish({ kbId, versionId = null }: { kbId: string; versionId?: string | null; }): Promise<PublishResponse> {
+    const params = {
+      kbId,
+      versionId,
+    };
+
+    return this.callApi<PublishResponse>({
+      method: 'POST',
+      route: '/kb/publish',
+      params,
+      data: null,
+    });
+  }
+
+  /**
+   * Recover knowledge model version
+   * ```typescript
+   * const result = await knowledgeModels.recover({ kbId: 'kb-id', versionId: 'version-id' });
+   * ```
+   */
+  public async recover({ kbId, versionId }: { kbId: string; versionId: string; }): Promise<void> {
+    const params = {
+      kbId,
+      versionId,
+    };
+
+    await this.callApi<void>({
+      method: 'POST',
+      route: '/kb/recover',
+      params,
+      data: null,
+    });
+  }
+
+  /**
+   * Delete knowledge model version
+   * ```typescript
+   * const result = await knowledgeModels.recover({ kbId: 'kb-id', versionId: 'version-id' });
+   * ```
+   */
+  public async deleteVersion({ kbId, versionId }: { kbId: string; versionId: string; }): Promise<void> {
+    const params = {
+      kbId,
+      versionId,
+    };
+
+    await this.callApi<void>({
+      method: 'DELETE',
+      route: '/kb/versions',
+      params,
+    });
+  }
+
+  /**
+   * Clone knowledge model
+   * ```typescript
+   * const result = await knowledgeModels.clone({ kbId: 'kb-id', newName: 'New name' });
+   * ```
+   */
+  public async clone({ kbId, newName }: { kbId: string; newName: string; }): Promise<CloneResponse> {
+    const data = {
+      newName,
+    };
+
+    const params = {
+      id: kbId,
+    };
+
+    return this.callApi<CloneResponse>({
+      method: 'POST',
+      route: '/knowledge-base/clone',
+      params,
+      data,
+    });
+  }
+
+  /**
+   * Export knowledge model
+   * ```typescript
+   * const file = await knowledgeModels.export({ kbId: 'kb-id', isPublic: true });
+   * ```
+   */
+  public async export({ kbId, isPublic }: { kbId: string; isPublic?: boolean; }): Promise<string> {
+    const params = {
+      id: kbId,
+      isPublic,
+    };
+
+    return this.callApi<string>({
+      method: 'GET',
+      route: '/knowledge-base/export',
+      params,
+    });
+  }
+
+  /**
+   * Import knowledge model
+   * ```typescript
+   * const result = await knowledgeModels.import({ fileUrl: 'http://file.url', knowledgeBase: {} });
+   * ```
+   */
+  public async import({ fileUrl, knowledgeBase }: { fileUrl: string; knowledgeBase: KnowledgeModelCreateParams; }): Promise<ImportResponse> {
+    const data = {
+      fileUrl,
+      knowledgeBase,
+    };
+
+    return this.callApi<ImportResponse>({
+      method: 'POST',
+      route: '/knowledge-base/import',
+      data,
+    });
+  }
+
+  /**
+   * Import knowledge model from JSON
+   * ```typescript
+   * const result = await knowledgeModels.importJson(jsonString);
+   * ```
+   */
+  public async importJson(data: string): Promise<ImportResponse> {
+    return this.callApi<ImportResponse>({
+      method: 'POST',
+      route: '/knowledge-base/import/json',
+      data,
+    });
+  }
+
+  /**
+   * Import knowledge model from csv
+   * ```typescript
+   * const result = await knowledgeModels.importCsv({ fileUrl: 'http://file.url', knowledgeBase: {}, applicationName: 'appName', delimiter: 'delimiter' });
+   * ```
+   */
+  public async importCsv({ fileUrl, knowledgeBase, applicationName, delimiter }: { fileUrl: string; knowledgeBase: KnowledgeModelCreateParams; applicationName?: string; delimiter?: string; }): Promise<ImportResponse> {
+    const data = {
+      fileUrl,
+      knowledgeBase,
+      applicationName,
+      delimiter,
+    };
+
+    return this.callApi<ImportResponse>({
+      method: 'POST',
+      route: '/knowledge-base/import/csv',
+      data,
+    });
+  }
+
+  /**
+   * meaning
+   * ```typescript
+   * const result = await knowledgeModels.meaning(???);
+   * ```
+   */
+  public async meaning(data: {
+    q: string;
+    appId: string;
+    kbId: string;
+    suggestedConfidenceRange?: [number, number];
+    unrecognizedConfidenceRange?: [number, number];
+    allowSuggested: boolean;
+    allowUnrecognized: boolean;
+    spellCheckEnabled?: boolean;
+    phraseId: string;
+    sessionId: string;
+    flowId: string;
+  }): Promise<MeaningResponse> {
+    return this.callApi<MeaningResponse>({
+      method: 'POST',
+      route: '/meaning',
+      data,
+    });
+  }
+
+  /**
+   * Test meaning
+   * ```typescript
+   * const result = await knowledgeModels.testMeaning({ q: 'text', appId: 'app-id', kbId: 'kb-id' });
+   * ```
+   */
+  public async testMeaning({ q, appId, kbId }: { q: string; appId: string; kbId: string; }): Promise<MeaningResponse> {
+    const data = {
+      q,
+      appId,
+      kbId,
+    };
+
+    return this.callApi<MeaningResponse>({
+      method: 'POST',
+      route: '/meaning/test',
+      data,
+    });
+  }
+}