@memori.ai/memori-api-client 0.2.1 → 0.3.1

package/dist/types.d.ts

@@ -46,16 +46,21 @@ export declare type Memori = {
     culture?: string;
     publishedInTheMetaverse?: boolean;
     metaverseEnvironment?: string;
+    exposed?: boolean;
     properties?: {
         [key: string]: string;
     };
     creationTimestamp?: string;
     lastChangeTimestamp?: string;
+    blockedUntil?: string;
     integrations?: Integration[];
     sentInvitations?: Invitation[];
     receivedInvitations?: Invitation[];
     categories?: string[];
     ownerUserName?: string;
+    gamificationLevel?: GamificationLevel;
+    contentQualityIndex?: number;
+    contentQualityIndexTimestamp?: string;
 };
 export declare type Venue = {
     placeName: string;
@@ -63,6 +68,29 @@ export declare type Venue = {
     longitude: number;
     uncertainty?: number;
 };
+export declare type NotificationPrefs = {
+    /**
+     * @type {string='None'}
+     * minLength: 1
+     * Periodicity of chat log extraction (hourly, daily, weekly or none).
+     * When chat log extraction is enabled (i.e. not None) chats performed on Memori owned or managed by the User
+     * will be periodically collected and sent via e-mail.
+     */
+    chatLogExtractionPeriod?: 'None' | 'Hourly' | 'Daily' | 'Weekly';
+    /**
+     * @type {number=5}
+     * Minimum lines for an extracted chat to be sent via e-mail to the User.
+     * If 0 no filter is applied.
+     * Default is 5.
+     */
+    chatLogExtractionMinLines?: number;
+    /**
+     * @type {string=}
+     * Memori ID to which these preferences apply to.
+     * If Null these preferences have default value and apply to all Memori objects not specified with other preferences.
+     */
+    memoriID?: string;
+};
 export declare type User = {
     tenant?: string;
     userID?: string;
@@ -78,12 +106,18 @@ export declare type User = {
     maxMemori?: number;
     canCreateMemori?: boolean;
     canAccessAPI?: boolean;
+    canRunSnippets?: boolean;
     canEditIntegrations?: boolean;
     canEditDynamicIntents?: boolean;
     canEditMemoriChaining?: boolean;
     maxFreeSessions?: number;
+    nonFreeSessionCost?: number;
     creationTimestamp?: string;
     lastChangeTimestamp?: string;
+    referral?: string;
+    couponCode?: string;
+    paying?: boolean;
+    notificationPrefs?: NotificationPrefs[];
 };
 export declare type IntegrationResource = {
     name: string;
@@ -160,6 +194,7 @@ export declare type Tenant = {
     usersCanEditMemoriChaining?: boolean;
     maxFreeSessions?: number;
     maxFreeSessionsPerUser?: number;
+    nonFreeSessionCost?: number;
 };
 export declare type OpenSession = {
     memoriID: string;
@@ -212,7 +247,7 @@ export declare type GamificationLevel = {
     points: number;
     badge: string;
     pointsForCurrentBadge: number;
-    nextBadge: {
+    nextBadge?: {
         points: number;
         badge: string;
     };
@@ -404,7 +439,289 @@ export declare type UnansweredQuestion = {
 };
 export declare type Message = {
     text: string;
+    translatedText?: string;
     fromUser?: boolean;
     media?: Medium[];
     initial?: boolean;
+    timestamp?: string;
+    contextVars?: {
+        [key: string]: string;
+    };
+};
+export declare type ConsumptionLog = {
+    consumptionLogID: string;
+    from: string;
+    to: string;
+    type: 'Daily' | 'Monthly';
+    userID?: string;
+    memoriID?: string;
+    totalSessions: number;
+    validSessions: number;
+};
+export declare type Notification = {
+    notificationID: string;
+    timestamp: string;
+    severity: 'INFO' | 'WARN' | 'ALERT';
+    texts: {
+        'it-IT': string;
+        'en-US': string;
+        [lang: string]: string;
+    };
+};
+export declare type ChatMedium = {
+    /**
+     * URL of the Medium. If specified, the Content property is Null.
+     */
+    url?: string;
+    /**
+     * Content of the Medium. If specified, the URL property is Null.
+     */
+    content?: string;
+    /**
+     * MIME type of the Medium.
+     */
+    mimeType: string;
+    /**
+     * Title of the Medium.
+     */
+    title?: string;
+    /**
+     * Key-value pairs for additional structured content storage.
+     */
+    properties?: {
+        [key: string]: string;
+    };
+};
+export declare type ChatLogLine = {
+    /**
+     * @type {string}
+     * Timestamp UTC of the line.
+     */
+    timestamp: string;
+    /**
+     * @type {boolean}
+     * If True the line is the text from a Text Entered Event. If False the line is Dialog State Machine emission.
+     */
+    inbound: boolean;
+    /**
+     * @type {string}
+     * Text of the line.
+     */
+    text: string;
+    /**
+     * Media attached with the Dialog State Machine emission, if present. Empty if the line is inbound.
+     */
+    media?: ChatMedium[];
+    /**
+     * Dialog State Machine context variables after the emission, if present. Empty if the line is inbound.
+     */
+    contextVars?: {
+        [key: string]: string;
+    };
+};
+export declare type ChatLog = {
+    /**
+     * @param {string}
+     * Chat Log object ID.
+     */
+    chatLogID: string;
+    /**
+     * @type {string}
+     * Timestamp UTC of the chat log creation.
+     */
+    timestamp: string;
+    /**
+     * @type {string}
+     * ID of the related Memori object in the Engine.
+     * Relates to Memori.engineMemoriID
+     */
+    memoriID: string;
+    /**
+     * @type {string}
+     * ID of the related session.
+     */
+    sessionID: string;
+    /**
+     * @type {?string}
+     * Tag of the Person object authenticated in the session. Null if the chat was performed by anonymous.
+     */
+    receiverTag?: string;
+    /**
+     * List of Chat Line objects of this chat.
+     */
+    lines: ChatLogLine[];
+};
+export declare type Utterance = {
+    /**
+     * Utterance object ID.
+     */
+    utteranceID?: string;
+    /**
+     * Accepted Utterance object for its corresponding intent,
+     * i.e. the text sentece that can be used to express the intent.
+     * An Utterance may include variable parts in the sentence by the use of one or more slots.
+     * Slots are specified using the syntax {slot}, where "slot" is the slot name.
+     * If present, their value is part of the IntentWebHookRequest passed to the web hook.
+     * Each slot can be present only once in the sentence, and must have been previously defined with a Intent Slot object.
+     * A special slot is the {date} slot, which represents a period of time such as "today", "yesterday", "last week", "next month" etc.
+     * Its values is passed in the IntentWebHookRequest as the BeginUTC and EndUTC properties.
+     */
+    text: string;
+    /**
+     * Timestamp of creation.
+     * Always present when reading/receiving an object,
+     * ignored when writing/sending an object.
+     */
+    creationTimestamp?: string;
+    /**
+     * ID of the session that created this object.
+     */
+    creationSessionID?: string;
+    /**
+     * Timestamp of latest change.
+     * Always present when reading/receiving an object,
+     * ignored when writing/sending an object.
+     */
+    lastChangeTimestamp?: string;
+    /**
+     * ID of the latest session that changed this object.
+     */
+    lastChangeSessionID?: string;
+};
+export declare type Intent = {
+    /**
+     * Intent object ID.
+     */
+    intentID?: string;
+    /**
+     * Memory type, e.g. Internal or WebHook.
+     * Internal intents are a limited subset implemented internally,
+     * while WebHook intents perform an external HTTP POST call to the specified web hook,
+     * passing an IntentWebHookRequest and expecting an IntentWebHookRespose in response.
+     * When updating an existing intent, this property is ignored.
+     */
+    intentType?: 'Internal' | 'WebHook';
+    /**
+     * Name of the Intent object.
+     * It is part of the IntentWebHookRequest request passed to the web hook.
+     */
+    name: string;
+    /**
+     * List of accepted Utterance objects for this Intent,
+     * i.e. the list of text senteces that can be used to express the intent.
+     * Utterances may include variable parts in the sentence by the use of one or more slots.
+     * Slots are specified using the syntax {slot}, where "slot" is the slot name.
+     * If present, their value is part of the IntentWebHookRequest passed to the web hook.
+     * Each slot can be present only once in the sentence, and must have been previously defined with a Intent Slot object.
+     * A special slot is the {date} slot, which represents a period of time such as "today", "yesterday", "last week", "next month" etc.
+     * Its values is passed in the IntentWebHookRequest as the BeginUTC and EndUTC properties.
+     */
+    utterances: Utterance[];
+    /**
+     * If True this Intent may be executed to serve a Timeout event in R1 state.
+     * In this case the utterance is null.
+     * In case more than one Intent have this flag set, a random one is picked.
+     */
+    timeoutIntent?: boolean;
+    /**
+     * HTTP URL of the web hook to be called when the intent is recognized.
+     * If the intent is of Internal type, it is ignored.
+     */
+    webHook?: string;
+    /**
+     * Time to cache the intent response, expressed in minutes.
+     * May be fractional. A minimum of 0.1 minutes (i.e. 6 seconds) is always applied.
+     * A cached intent response is used only when the a subsequent intent request matches exactly the original request.
+     * See also RequestValidityMinutes in WebHookRequest.
+     */
+    validityMinutes?: number;
+    /**
+     * Timestamp of creation.
+     * Always present when reading/receiving an object,
+     * ignored when writing/sending an object.
+     */
+    creationTimestamp?: string;
+    /**
+     * ID of the session that created this object.
+     */
+    creationSessionID?: string;
+    /**
+     * Timestamp of latest change.
+     * Always present when reading/receiving an object,
+     * ignored when writing/sending an object.
+     */
+    lastChangeTimestamp?: string;
+    /**
+     * ID of the latest session that changed this object.
+     */
+    lastChangeSessionID?: string;
+};
+export declare type IntentSlot = {
+    /**
+     * Intent Slot object ID.
+     */
+    intentSlotID?: string;
+    /**
+     * Name of the Intent Slot object.
+     * It is part of the SlotWebHookRequest request passed to the web hook.
+     */
+    name: string;
+    /**
+     * List of possible values of the slot.
+     * A slot may be composed of fixed values in this property,
+     * dynamic values fetched from the web hook, or a combination of both.
+     * Each value is considered only onces (duplicate values are ignored).
+     */
+    values?: string[];
+    /**
+     * HTTP URL of the web hook to be called when the slot values must be fetched.
+     * May be null if the slot is composed only of fixed values in the Values property.
+     * If specified, the web hook is called periodically with an HTTP POST call,
+     * passing a SlotWebHookRequest and expecting a SlotWebHookRespose in response.
+     * Periodicity is determined by the ValidityMinutes property.
+     */
+    webHook?: string;
+    /**
+     * Time to cache the slot values, expressed in minutes.
+     * May be fractional. A minimum of 0.5 minutes (i.e. 30 seconds) is always applied.
+     * See also RequestValidityMinutes in WebHookRequest.
+     */
+    validityMinutes?: number;
+    /**
+     * Timestamp of creation.
+     * Always present when reading/receiving an object,
+     * ignored when writing/sending an object.
+     */
+    creationTimestamp?: string;
+    /**
+     * ID of the session that created this object.
+     */
+    creationSessionID?: string;
+    /**
+     * Timestamp of latest change.
+     * Always present when reading/receiving an object,
+     * ignored when writing/sending an object.
+     */
+    lastChangeTimestamp?: string;
+    /**
+     * ID of the latest session that changed this object.
+     */
+    lastChangeSessionID?: string;
+};
+export declare type CustomWord = {
+    customWordID: string;
+    word: string;
+    /**
+     * Definition of the Custom Word, in terms of sums and subtractions of existing words or custom words.
+     * The syntax for a Custom Word definition is as follows: word1 [+-] word2 [+-] word3...
+     * If the operator is omitted it is assumed to be the last specified from the left, and if no operator has been specified it is assumed to be the sum.
+     * E.g.:
+     *  - alpha beta gamma is equivalent to alpha + beta + gamma
+     *  - alpha beta - gamma deta is equivalent to alpha + beta - gamma - delta
+     */
+    definition: string;
+    creationTimestamp: string;
+    creationSessionID: string;
+    lastChangeTimestamp: string;
+    lastChangeSessionID: string;
 };

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2.1",
+  "version": "0.3.1",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [

package/src/apiFetcher.ts

@@ -7,6 +7,7 @@ export const apiFetcher = (
     method?: string;
     body?: object;
     headers?: object;
+    text?: boolean;
   }
 ) =>
   fetch(`${opts.apiUrl}${path}`, {
@@ -19,4 +20,4 @@ export const apiFetcher = (
       'Content-Type': 'application/json',
       ...opts?.headers,
     },
-  }).then(res => res.json());
+  }).then(res => (opts?.text ? res.text() : res.json()));

package/src/backend/consumptionLogs.ts

@@ -0,0 +1,79 @@
+import { ResponseSpec, ConsumptionLog } from '../types';
+import { apiFetcher } from '../apiFetcher';
+
+export default (apiUrl: string) => ({
+  /**
+   * Gets the Consumption Log objects for a specific Tenant in a specific date interval.
+   * @param {string} authToken - The login token
+   * @param {string} tenantID - The name of the tenant
+   * @param {string} type - Type of consumption (i.e. granularity), it may either be Daily or Monthly
+   * @param {string=} dateFrom - The optional begin of the date interval, in UTC time, in the format yyyyMMdd
+   * @param {string=} dateTo - The optional end of the date interval, in UTC time, in the format yyyyMMdd
+   * @returns The list of Consumption Logs objects.
+   */
+  getTenantConsumptionLogs: (
+    authToken: string,
+    tenantID: string,
+    type: 'Daily' | 'Monthly',
+    dateFrom?: string,
+    dateTo?: string
+  ) =>
+    apiFetcher(
+      `/TenantConsumptionLogs/${authToken}/${tenantID}/${type}${
+        dateFrom ? `/${dateFrom}` : ''
+      }${dateFrom && dateTo ? `/${dateTo}` : ''}`,
+      {
+        apiUrl,
+      }
+    ) as Promise<ResponseSpec & { consumptionLogs: ConsumptionLog[] }>,
+
+  /**
+   * Gets the Consumption Log objects for a specific User in a specific date interval.
+   * @param {string} authToken - The login token
+   * @param {string} userID - The ID of the User object
+   * @param {string} type - Type of consumption (i.e. granularity), it may either be Daily or Monthly
+   * @param {string=} dateFrom - The optional begin of the date interval, in UTC time, in the format yyyyMMdd
+   * @param {string=} dateTo - The optional end of the date interval, in UTC time, in the format yyyyMMdd
+   * @returns The list of Consumption Logs objects.
+   */
+  getUserConsumptionLogs: (
+    authToken: string,
+    userID: string,
+    type: 'Daily' | 'Monthly',
+    dateFrom?: string,
+    dateTo?: string
+  ) =>
+    apiFetcher(
+      `/UserConsumptionLogs/${authToken}/${userID}/${type}${
+        dateFrom ? `/${dateFrom}` : ''
+      }${dateFrom && dateTo ? `/${dateTo}` : ''}`,
+      {
+        apiUrl,
+      }
+    ) as Promise<ResponseSpec & { consumptionLogs: ConsumptionLog[] }>,
+
+  /**
+   * Gets the Consumption Log objects for a specific Memori in a specific date interval.
+   * @param {string} authToken - The login token
+   * @param {string} memoriID - The ID of the Memori object
+   * @param {string} type - Type of consumption (i.e. granularity), it may either be Daily or Monthly
+   * @param {string=} dateFrom - The optional begin of the date interval, in UTC time, in the format yyyyMMdd
+   * @param {string=} dateTo - The optional end of the date interval, in UTC time, in the format yyyyMMdd
+   * @returns The list of Consumption Logs objects.
+   */
+  getMemoriConsumptionLogs: (
+    authToken: string,
+    memoriID: string,
+    type: 'Daily' | 'Monthly',
+    dateFrom?: string,
+    dateTo?: string
+  ) =>
+    apiFetcher(
+      `/MemoriConsumptionLogs/${authToken}/${memoriID}/${type}${
+        dateFrom ? `/${dateFrom}` : ''
+      }${dateFrom && dateTo ? `/${dateTo}` : ''}`,
+      {
+        apiUrl,
+      }
+    ) as Promise<ResponseSpec & { consumptionLogs: ConsumptionLog[] }>,
+});

package/src/backend/memori.ts

@@ -223,4 +223,24 @@ export default (apiUrl: string) => ({
         validSessions: number;
       }
     >,
+
+  /**
+   * Transfers an existing Memori object to another User.
+   * The new owner must be specified by either a OwnerUserID or a OwnerUserName-OwnerTenantName pair.
+   * The OwnerUserName may also specify a user e-mail.
+   * @param {string} authToken - The login token
+   * @param {Memori} memori - The Memori object
+   */
+  transferMemori: (
+    authToken: string,
+    memori: Memori & {
+      ownerTenantName: string;
+      ownerUserName: string;
+    }
+  ) =>
+    apiFetcher(`/TransferMemori/${authToken}`, {
+      apiUrl,
+      body: memori,
+      method: 'POST',
+    }) as Promise<ResponseSpec>,
 });

package/src/backend/notifications.ts

@@ -0,0 +1,24 @@
+import { ResponseSpec, Notification } from '../types';
+import { apiFetcher } from '../apiFetcher';
+
+export default (apiUrl: string) => ({
+  /**
+   * Gets the Notification objects available for a specific Tenant.
+   * @param {string} tenantID - The name of the tenant
+   * @returns The list of Notification objects.
+   */
+  getTenantNotifications: (tenantID: string) =>
+    apiFetcher(`/TenantNotifications/${tenantID}`, {
+      apiUrl,
+    }) as Promise<ResponseSpec & { notifications: Notification[] }>,
+
+  /**
+   * Gets the Notification objects available for a specific User.
+   * @param {string} authToken - The login token
+   * @returns The list of Notification objects.
+   */
+  getUserNotifications: (authToken: string) =>
+    apiFetcher(`/UserNotifications/${authToken}`, {
+      apiUrl,
+    }) as Promise<ResponseSpec & { notifications: Notification[] }>,
+});

package/src/backend.ts

@@ -3,6 +3,8 @@ import user from './backend/user';
 import integration from './backend/integration';
 import asset from './backend/asset';
 import invitation from './backend/invitation';
+import consumptionLogs from './backend/consumptionLogs';
+import notifications from './backend/notifications';
 
 const backendAPI = (apiUrl: string) => ({
   asset: asset(apiUrl),
@@ -10,11 +12,15 @@ const backendAPI = (apiUrl: string) => ({
   user: user(apiUrl),
   integration: integration(apiUrl),
   invitation: invitation(apiUrl),
+  consumptionLogs: consumptionLogs(apiUrl),
+  notifications: notifications(apiUrl),
   ...asset(apiUrl),
   ...memori(apiUrl),
   ...user(apiUrl),
   ...integration(apiUrl),
   ...invitation(apiUrl),
+  ...consumptionLogs(apiUrl),
+  ...notifications(apiUrl),
 });
 
 export default backendAPI;

package/src/engine/chatLogs.ts

@@ -0,0 +1,63 @@
+import { ChatLog, ResponseSpec } from '../types';
+import { apiFetcher } from '../apiFetcher';
+
+/*************************
+ *                       *
+ *       ChatLogs        *
+ *                       *
+ *************************/
+
+export default (apiUrl: string) => ({
+  /**
+   * Gets the Chat Log objects for the Memori of the current session in a specific date interval.
+   * @param {string} sessionId The session ID
+   * @param {?string} dateFrom The optional begin of the date interval, in UTC time, in the format yyyyMMddHHmmssfff
+   * @param {?string} dateTo The optional end of the date interval, in UTC time, in the format yyyyMMddHHmmssfff
+   */
+  getChatLogs: async (sessionId: string, dateFrom?: string, dateTo?: string) =>
+    apiFetcher(
+      `/ChatLogs/${sessionId}${dateFrom ? `/${dateFrom}` : ''}${
+        dateFrom && dateTo ? `/${dateTo}` : ''
+      }`,
+      {
+        method: 'GET',
+        apiUrl,
+      }
+    ) as Promise<
+      ResponseSpec & {
+        chatLogs: ChatLog[];
+      }
+    >,
+
+  /**
+   * Removes all Chat Log objects in a specific date internval.
+   * @param {string} sessionId The session ID
+   * @param {?string} dateFrom The optional begin of the date interval, in UTC time, in the format yyyyMMddHHmmssfff
+   * @param {?string} dateTo The optional end of the date interval, in UTC time, in the format yyyyMMddHHmmssfff
+   */
+  deleteChatLogs: async (
+    sessionId: string,
+    dateFrom?: string,
+    dateTo?: string
+  ) =>
+    apiFetcher(
+      `/ChatLogs/${sessionId}${dateFrom ? `/${dateFrom}` : ''}${
+        dateFrom && dateTo ? `/${dateTo}` : ''
+      }`,
+      {
+        method: 'DELETE',
+        apiUrl,
+      }
+    ) as Promise<ResponseSpec>,
+
+  /**
+   * Removes an existing Chat Log object.
+   * @param {string} sessionId The session ID
+   * @param {string} chatLogId The Chat Log object ID
+   */
+  deleteChatLog: async (sessionId: string, chatLogId: string) =>
+    apiFetcher(`/ChatLog/${sessionId}/${chatLogId}`, {
+      method: 'DELETE',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+});

package/src/engine/customDictionary.ts

@@ -0,0 +1,85 @@
+import { ResponseSpec, CustomWord } from '../types';
+import { apiFetcher } from '../apiFetcher';
+
+/****************************
+ *                          *
+ *     CustomDictionary     *
+ *                          *
+ ****************************/
+
+export default (apiUrl: string) => ({
+  /**
+   * Lists all Custom Words.
+   * @param {string} sessionId The session ID
+   */
+  getCustomWords: async (sessionId: string) =>
+    apiFetcher(`/CustomWords/${sessionId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        customWords: CustomWord[];
+      }
+    >,
+
+  /**
+   * Gets the details of a Custom Word object.
+   * @param {string} sessionId The session ID
+   * @param {string} customWordID The Custom Word object ID
+   */
+  getCustomWord: async (sessionId: string, customWordID: string) =>
+    apiFetcher(`/CustomWord/${sessionId}/${customWordID}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        customWord: CustomWord;
+      }
+    >,
+
+  /**
+   * Removes an existing Custom Word object.
+   * @param {string} sessionId The session ID
+   * @param {string} key The key of the Custom Word
+   */
+  deleteCustomWord: async (sessionId: string, key: string) =>
+    apiFetcher(`/CustomWord/${sessionId}/${key}`, {
+      method: 'DELETE',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+
+  /**
+   * Adds a new Custom Word object.
+   * @param {string} sessionId The session ID
+   * @param {CustomWord} customWord Custom Word
+   */
+  postCustomWord: async (
+    sessionId: string,
+    customWord: Pick<CustomWord, 'word'> & Pick<CustomWord, 'definition'>
+  ) =>
+    apiFetcher(`/CustomWord/${sessionId}`, {
+      method: 'POST',
+      apiUrl,
+      body: customWord,
+    }) as Promise<
+      ResponseSpec & {
+        customWord: CustomWord;
+      }
+    >,
+
+  /**
+   * Updates an existing Custom Word object.
+   * Only the Definition field is considered for update. To change the Word field a new Custom Word must be added and the existing must be removed.
+   * @param {string} sessionId The session ID
+   * @param {CustomWord} customWord Custom Word
+   */
+  patchCustomWord: async (
+    sessionId: string,
+    customWord: Partial<CustomWord> & { customWordID: string }
+  ) =>
+    apiFetcher(`/CustomWord/${sessionId}/${customWord.customWordID}`, {
+      method: 'PATCH',
+      apiUrl,
+      body: customWord,
+    }) as Promise<ResponseSpec>,
+});