testaugnitosdk2 1.0.12

package/README.md

@@ -0,0 +1,442 @@
+# Augnito Speech SDK
+
+You can use **Augnito SDK** to make use of the Speech Recognition AI. To get access credentials or talk to us about your project, get in touch with us at <partnerships@augnito.ai>.
+
+## Installation
+
+Install the library in your Typescript project.
+
+### [Typescript](#tab/tab-ts)
+
+```ts
+    npm install augnitosdk
+```
+
+_Note: If you wish to integrate augnitosdk with CKEDitor 5 editor then please make sure to install @ckeditor/ckeditor5-core package using below command_
+
+```js
+npm install @ckeditor/ckeditor5-core
+```
+
+### [Vanilla JS](#tab/tab-js)
+
+use https://cdn.jsdelivr.net/npm/augnitosdk@latest/dist/augnitosdk.js to import the library from npm using CDN url.
+
+## Basic Usage
+
+### 1- Import the library
+
+### [Typescript](#tab/tab-ts)
+
+```ts
+import { Augnito } from 'augnitosdk';
+```
+
+### [Vanilla JS](#tab/tab-js)
+
+```js
+import { Augnito } from 'https://cdn.jsdelivr.net/npm/augnitosdk@latest/dist/augnitosdk.js';
+```
+
+Note - All other steps are common for Vanilla JS and Typescript implementations.
+
+### 2- Create the configuration file and instantiate Augnito Client
+
+```js
+const augnitoConfig: AugnitoConfig = {
+  server: '<your domain server>',
+  accountCode: '<your accountcode>',
+  accessKey: '<your accesskey>',
+  userTag: '<your usertag>',
+  sourceApp: '<your sourceapp>',
+  lmId: '<your lmid>'
+  noiseCt: 1, //Optional parameter, to set noice cancellation value and default value is 1 which is off
+  enableLogs: false, // Optional parameter, to check debug logs set to true
+  listOfControls: [], // Optional parameter, set a list of type TargetEditor. Setting editor instance is necessary for EditorType.DEVEXPRESS and to handle navigation command between fields
+  editor: EditorType.HTML, // Optional parameter, set EditorType enum for SDK to insert sppech-to-text display at cursor placed inside field and to handle commands dictated. Other enum values are EditorType.CKEDITOR4 | EditorType.CKEDITOR5 | EditorType.GENERIC | EditorType.DEVEXPRESS,
+  earlyInitialiseRecorder: false, // Optional parameter, set it to true if required to initialise recorder mic as soon as page is loaded so as to start listening immediately on mic button click
+  pauseStateBufferInterval: 1, // Optional parameter, set value between 0-1 if earlyInitialiseRecorder is set to true and the value indicates interval (in seconds) of audio which needs to be streamed while resuming mic,
+  switchToRegularSpeechProfile: false, //Optional parameter, set to true for using regular speech profile else by default it is set to fast speech profile
+};
+
+const augnito = new Augnito(augnitoConfig);
+```
+
+### 3- Toggle the client!
+
+Now all you have to do is toggle the status when you want to connect/disconnect!
+
+```js
+// Toggles the Speech API connection. Set optional parameter shouldPauseResume to true to toggle pause and resume dictation. This will ensure socket connection remains connected throughout. If no parameter is given, then the method will function as toggle of start and stop dictation. This will create a new socket connection on every start
+augnito.toggleListening((shouldPauseResume = false));
+
+augnito.requestMicOff(); //call this method to close the socket connection and clear all resources in case shouldPauseResume is set to true
+```
+
+## Mobile Application
+
+Whether you want to use the **Augnito Mic** as your microphone, or you want to develop your own app, we got you covered.
+
+All you have to do is initialize the mobile configuration. The SDK will generate a value that you need to use to generate a QR code which should be scanned in the App.
+
+```js
+import { AugnitoMobileConfig } from 'augnitosdk';
+
+const mobileConfig: AugnitoMobileConfig = {
+  enableLogs: false
+};
+const augnitoMobile = augnito.initMobileClient(mobileConfig);
+
+//Generate a QR Code with the following value
+const code = augnito.getQRCode();
+```
+
+## Config Philips Speech Mic
+
+If you have a Philips speech mic and want to use it as the input device, then include the below code.
+
+```js
+import { PhilipsMicMode } from 'augnitosdk';
+
+const philipMicConfig = {
+  philipsMicMode: PhilipsMicMode['HandsFree'] //other options include PhilipsMicMode.PushToTalk or PhilipsMicMode.BOTH
+};
+const philipMicHandler = augnito.initPhilipMicClient(philipMicConfig);
+```
+
+- HandsFree - where you push the record button speak and the push the button to stop
+- PushToTalk - where you press and hold the record button to speak. Release of the button will stop
+- BOTH - SDK will intelligently handle the other two modes based on user action
+
+## Augnito - Speech Related Callbacks
+
+| Name                | type                                    | Description                                                                                                                                                         |
+| ------------------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| onPartialResult     | (text: string) => void                  | Partial Result generated from the server                                                                                                                            |
+| onFinalResult       | (finalText: Recipe) => boolean          | A final result is called when text has been processed by the Speech Server. Returns `true` to stop the processing in the SDK                                        |
+| onCommandResult     | (command: Recipe) => boolean            | A command generated from the server. Returns `true` to stop the processing in the SDK                                                                               |
+| onStateChanged      | (isConnected: boolean) => void          | Callback to indicate the status of the microphone listening state has changed.                                                                                      |
+| onSessionEvent      | (data: AugnitoSocketResponse) => void   | Callback to intercept Session Events                                                                                                                                |
+| onIdleMic           | () => void                              | Callback when the Mic is idle for 5 minutes                                                                                                                         |
+| onMicrophoneOnError | (isWebClient: boolean) => void          | Callback triggered when trying to start the connection, but it fails because it is already opened. (It can be opened in another tab, or it was not closed properly) |
+| onError             | (error: AugnitoSDKErrorMessage) => void | Callback triggered when the SDK encouters an error                                                                                                                  |
+
+## Augnito Mobile - Speech Related Callbacks
+
+| Name                | type       | Description                                            |
+| ------------------- | ---------- | ------------------------------------------------------ |
+| onConnectionRequest | () => void | Callback when a mobile client is requesting to connect |
+| onMobileScan        | () => void | Callback when a mobile client has scanned the QR Code  |
+
+## Philips Speech Mic Related Callbacks
+
+| Name                | type       | Description                                                  |
+| ------------------- | ---------- | ------------------------------------------------------------ |
+| onPhilipsMicPressed | () => void | Callback when record button is pressed on Philips Speech Mic |
+
+### Augnito Methods
+
+| prop                | type             | notes                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| ------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| toggleListening     | void             | Toggles the Speech API connection: if already connected, it will stop the web socket; otherwise, it will start a new connection. If optional parameter shouldPauseResume is set to true then listening to mic will be suspended and resumed, here web socket will remain alive throughout the session. Consumers of the sdk are expected to call requestMicOff to stop the web sockeet and clean the resources in the end |
+| isConnected         | boolean          | Returns the status of the web socket: true if connected; otherwise false.                                                                                                                                                                                                                                                                                                                                                 |
+| getQRCode           | string           | Returns the Generated Value for the QR Code (If and only if the DeviceId was provided).                                                                                                                                                                                                                                                                                                                                   |
+| dispose             | void             | Dispose all resources.                                                                                                                                                                                                                                                                                                                                                                                                    |
+| initMobileClient    | AugnitoMobile    | Creates a web socket for getting notifications from client mobile application: only to be used with Mobile App                                                                                                                                                                                                                                                                                                            |
+| apisFactory         | FactoryAPI       | Returns an Abstract Factory to create different API Clients.                                                                                                                                                                                                                                                                                                                                                              |
+| requestMicOff       | void             | Sends a request to close all opened connections.                                                                                                                                                                                                                                                                                                                                                                          |
+| initPhilipMicClient | PhilipsMicClient | To be used with Philips Speecch Mic. It will listen to press event of record button on the mic.                                                                                                                                                                                                                                                                                                                           |
+
+## MacrosAPI
+
+### MacrosAPI Methods
+
+| name        | type                 | notes                                              |
+| ----------- | -------------------- | -------------------------------------------------- |
+| getMacros   | Promise: MacroResult | Returns a list of macros for the specified user.   |
+| upsertMacro | Promis: MacroResult  | Creates or Updates a Macro for the specified user. |
+| deleteMacro | Promise: MacroResult | Deletes a Macro for the specified user.            |
+
+### 1- Create Macros Client
+
+```js
+// If you already have an augnito client..
+const macrosClient = augnito.apisFactory.getMacrosAPI();
+
+// OR
+import { MacrosAPI } from 'augnitosdk';
+const macrosClient = new MacrosAPI(accountCode, accessKey, server);
+```
+
+### 2- Use the Macros Client to list, create, update or delete user macros
+
+```js
+macrosClient
+  .getMacros({
+    UserTag: userTag
+  })
+  .then((result) => {
+    console.log(result);
+  });
+```
+
+## Formatting Preference API
+
+### Formatting Preference API Interfaces
+
+```js
+interface Edge
+{
+  PK: string;
+  SK: string;
+}
+
+interface UserFormattingRequest
+{
+  PageId?: Edge; // Optional page edge for next and previous pages of search results
+  Limit?: number; // Optional limit for number of search results
+}
+
+interface FormattingItem
+{
+  SpokenForm: string; // The spoken form of the formatting preference
+  DisplayForm: string; // The display form of the formatting preference
+  ID: string; // The ID of the formatting preference
+}
+
+interface FormattingResult
+{
+  Status: number; // Response status code
+  ErrorMessage: string; // Error message if any
+  Data: {
+    StatusMessage: string; // Response status message
+    FormattingPreferenceItems? :
+    {
+        PageSize: number; // Number of items in the current page
+        PageIdNext?: Edge; // Next page edge if any
+        PageIdPrevious?: Edge; // Previous page edge if any
+        Items: Array<FormattingItem>; // List of formatting preferences
+    };
+  };
+}
+
+interface UpsertFormattingRequest {
+  SpokenForm: string; // The spoken form of the formatting preference
+  DisplayForm: string; // The display form of the formatting preference
+  ID?: string; // The ID of the formatting preference if updating an existing preference
+}
+
+RemoveFormattingRequest {
+  ID: string; // The Id of the formatting preference to be deleted
+}
+
+```
+
+### Formatting Preference API Methods
+
+| name                                               | type                      | notes                                                              |
+| -------------------------------------------------- | ------------------------- | ------------------------------------------------------------------ |
+| getFormatting(request: UserFormattingRequest)      | Promise: FormattingResult | Returns a list of formatting preferfences for the specified user.  |
+| upsertFormatting(request: UpsertFormattingRequest) | Promise: FormattingResult | Creates or Updates a formatting preference for the specified user. |
+| removeFormatting(request: RemoveFormattingRequest) | Promise: FormattingResult | Deletes a formatting preference for the specified user.            |
+
+### 1- Create Formatting Preference Client
+
+```js
+// If you already have an augnito client..
+const formattingAPI = augnito.apisFactory.getFormattingAPI();
+
+// OR
+import { FormattingAPI } from 'augnitosdk';
+const formattingAPI = new FormattingAPI({
+  UserCode: <your usercode>,
+  SubscriptionCode: <your subscription code>,
+  AccessKey: <your access key>,
+  SmId: <your sm id>,
+  DeviceCode: <your device code>,
+  SourceApp: <your source app>,
+  AccountCode: <your account code>,
+  Server: <your  server>,
+  EnableLogs: true | false,
+});
+
+```
+
+### 2- Use the Formatting Preference Client to list, create, update or delete user macros
+
+```js
+formatApi
+  .getFormatting({
+    Limit: 10
+  })
+  .then((result) => {
+    console.log('formatting', result);
+  });
+```
+
+## Vocabulary API
+
+Vocabulary items can be added to the model for a specific user and model.
+When the word has been added and is ready to be recognised a notification will be sent to the client and the microphone will need to be restarted.
+
+### Vocabulary Models
+
+```js
+interface Edge
+{
+  PK: string;
+  SK: string;
+}
+
+interface UserVocabularyRequest
+{
+  PageId?: Edge; // Optional page edge for next and previous pages of search results
+  Limit?: number; // Optional limit for number of search results
+}
+
+interface VocabularyItem
+{
+  Word: string; // The word
+  SpokenWord: string | null; // The , optional, spoken form of the word
+  IsAbbreviation: boolean; // Whether the word is an abbreviation or not
+  CreatedAt: Date; // The date the word was added to the vocabulary
+  Status: string; // The status of the word
+}
+
+interface VocabularyResult
+{
+  Status: number; // Response status code
+  ErrorMessage: string; // Error message if any
+  Data: {
+    StatusMessage: string; // Response status message
+    WordItems? :
+      {
+        SubscriptionCode: string; // The subscription code
+        UserCode: string; // The user code the word has been added for
+        PageSize: number; // Number of items in the current page
+        PageIdNext?: Edge; // Next page edge if any
+        PageIdPrevious?: Edge; // Previous page edge if any
+        Items: Array<VocabularyItem>; // List of vocabulary items
+      };
+  };
+}
+
+interface UpsertVocabularyRequest
+{
+  file: File; // Audio file of the word to be added
+  Word: string; // The word
+  SpokenWord: string; // The, optional, spoken form of the word
+  IsAbbreviation: boolean; // Whether the word is an abbreviation or not
+}
+
+interface RemoveVocabularyRequest
+{
+  Word: string; // The word to be removed
+}
+
+```
+
+### VocabularyAPI Methods
+
+| name                                               | type                      | notes                                                 |
+| -------------------------------------------------- | ------------------------- | ----------------------------------------------------- |
+| getVocabulary(request: UserVocabularyRequest)      | Promise: VocabularyResult | Returns a list of vocabulary for the specified user.  |
+| upsertFormatting(request: UpsertVocabularyRequest) | Promise: VocabularyResult | Creates or Updates vocabulary for the specified user. |
+| removeFormatting(request: RemoveVocabularyRequest) | Promise: VocabularyResult | Deletes a vocabulary for the specified user.          |
+
+### VocabularyAPI Callback
+
+| Name              | type                                           | Description                                             |
+| ----------------- | ---------------------------------------------- | ------------------------------------------------------- |
+| onVocabularyAdded | (notification: AugnitoAppNotification) => void | Notification that a vocabulary word has been processed. |
+
+### Vocbaulary Helper Methods
+
+| Name             | type                         | Description                                                  |
+| ---------------- | ---------------------------- | ------------------------------------------------------------ |
+| startRecording() | (Promise) => void            | Starts recording audio. Will turn off main Augnito mic if on |
+| stopRecording()  | (blob:Promise<Blob>) => void | Stops recording audio and returns the audio                  |
+
+The audio for the vocabulary to be added must be between 1 and 8 seconds long.
+If you call stop recording less than 1 second after start the recording will wait for a second to have passed since it started before resolving the promise.
+If you call stop recording more than 8 seconds after start the returned recording will be the first 8 seconds recorded.
+
+### 1- Create Vocabulary Client
+
+```js
+const vocabularyAPI = augnito.apisFactory.getVocabularyAPI();
+
+// Add a callback to be notified when a vocabulary word has been processed
+vocabularyAPI.onVocabularyAdded = (notification: AugnitoAppNotification) => {
+  console.log(notification);
+};
+
+```
+
+### 2 - Add a new vocabulary item
+
+```js
+
+// Start recording
+vocabularyAPI.startRecording();
+... // Record for 1-8 seconds
+// Stop recording
+vocabularyAPI.stopRecording().then((blob) => {
+  // Add the word to the vocabulary
+  vocabularyAPI.upsertVocabulary({
+    file: new File([blob], 'test.wav'),
+    Word: 'test',
+    SpokenWord: 'test',
+    IsAbbreviation: false,
+  });
+});
+
+```
+
+### 3 - List vocabulary items from multiple pages
+
+```js
+const loadWords = (page?: Edge) => {
+    vocabularyAPI
+      .getVocabulary({ Limit: 10, PageId: page })
+      .then(function (result) {
+        if (typeof result != 'string') {
+          result.Data.WordItems?.Items.forEach((value) => {
+            console.log(value);
+          });
+          if (result.Data.WordItems?.PageIdNext) {
+            loadWords( result.Data.WordItems.PageIdNext);
+          }
+        }
+      });
+  };
+
+  loadWords();
+```
+
+## MedicineOrderingAPI
+
+### MedicineOrderingAPI Methods
+
+| Name                 | type                                      | Description                                                    |
+| -------------------- | ----------------------------------------- | -------------------------------------------------------------- |
+| getMedicineOrderData | Promise: MedicineOrderingResult Or String | Returns medicine ordering data for text specified by the user. |
+
+### 1- Create MedicineOrdering Client
+
+```js
+// If you already have an augnito client..
+const orderingClient = augnito.apisFactory.getMedicineOrderingAPI();
+```
+
+### 2- Use the MedicineOrdering Client to get medicine order data in the following manner
+
+```js
+orderingClient
+  .getMedicineOrderData({
+    Text: ''
+  })
+  .then((result) => {
+    console.log(result);
+  });
+```

package/dist/Augnito.d.ts

@@ -0,0 +1,130 @@
+import { AugnitoConfig } from './config/AugnitoConfig';
+import { AugnitoMobileConfig } from './config/AugnitoMobileConfig';
+import { ActionRecipe } from './recipe/ActionRecipe';
+import { AugnitoSocketResponse } from './support/AugnitoSocketResponse';
+import { AugnitoMobile } from './AugnitoMobile';
+import { FactoryAPI } from './api/FactoryAPI';
+import { IConfiguration } from './config/IConfiguration ';
+import { AugnitoSDKErrorMessage } from './support/AugnitoSDKErrorMessage';
+import { PhilipsMicConfig } from './config/PhilipsMicConfig';
+import { PhilipsMicClient } from './client/PhilipsMicClient';
+/**
+ * Augnito Manager
+ * @description Handles the connection with the Speech API Server. Only one instance of the class should be created
+ */
+export declare class Augnito {
+    private _logTag;
+    /** Web Client */
+    private _webClient;
+    private _sdkMobileConfig;
+    /** Mobile Client */
+    private _augnitoMobile;
+    /** Web Worker */
+    private _worker;
+    private enableLogs;
+    private isConnected;
+    private switchToRegularSpeechProfile;
+    private shouldPreInitialiseMic;
+    private forceStopAudio;
+    private config;
+    private _factoryAPI;
+    private _editorHandler;
+    private recorderIns;
+    private _notificationClient;
+    /**
+     * @callback Callback partial results
+     * @description optional callback
+     */
+    onPartialResult?: (text: string) => void;
+    /**
+     * Callback to process Final Results
+     * @description A final result is called when text has been processed by the Speech Server
+     */
+    onFinalResult?: (finalText: Partial<ActionRecipe>) => boolean;
+    /**
+     * Callback to intercept Commands
+     */
+    onCommandResult?: (command: Partial<ActionRecipe>) => boolean;
+    /**
+     *  Callback for status changed
+     * @description Mandatory field
+     */
+    onStateChanged?: (isConnected: boolean) => void;
+    /**
+     * Callback to intercept Session Events
+     */
+    onSessionEvent?: (data: AugnitoSocketResponse) => void;
+    /**
+     * Iddle Callback: When the Mic is iddle for 5 minutes
+     * @description Mandatory field
+     */
+    onIdleMic?: () => void;
+    /**
+     * Callback triggered when trying to start the connection, but it fails because it is already opened.
+     * It can happen if the client has more than one tab opened.
+     * This error will ALSO come through on the onError handler if you don't have a handler attached to this callback.
+     * @param isWebClient If true, the error was raised from the Web Client; otherwise from the mobile client
+     */
+    onMicrophoneOnError?: (isWebClient: boolean) => void;
+    /**
+     * Callback triggered when an error occurs within the Augnito SDK
+     * @param error An object containing the error type and error message
+     */
+    onError?: (error: AugnitoSDKErrorMessage) => void;
+    constructor(config: AugnitoConfig);
+    /**
+     * Toggles the Speech API connection
+     * @description if already connected, it will stop the web socket; otherwise, it will start a new connection
+     */
+    toggleListening(shouldPauseResume?: boolean): void;
+    /**
+     * Returns the status of the web socket.
+     * @returns true if connected; otherwise false
+     */
+    /**
+     * Returns the Generated Value for the QR Code (If and only if the DeviceId was provided)
+     */
+    getQRCode(): string | undefined;
+    navigateToNextField(): void;
+    navigateToPreviousField(): void;
+    getCursorPosition(): any;
+    setCursorAtPosition(position: number): void;
+    setCursorAtDocumentEnd(): void;
+    /**
+     * Dispose all resources.
+     */
+    dispose(): void;
+    /**
+     * Creates a web socket for getting notifications from client mobile application
+     * @description To be used with Augnito Mobile SDK
+     * @param config Mobile config
+     */
+    initMobileClient(config?: AugnitoMobileConfig): AugnitoMobile;
+    initPhilipMicClient(config: PhilipsMicConfig): PhilipsMicClient;
+    /**
+     * Sends a request to close all opened connections.
+     * To be used in case the Augnito client is instantiated in multiple tabs
+     */
+    requestMicOff(): void;
+    addCustomCommand(commandName: string, callbackParameter: any, callbackFunction: any): void;
+    setAnchoredEditor(editor: Element | undefined, editorName: string | null): void;
+    /** Returns an Abstract Factory to create different API Clients */
+    get apisFactory(): FactoryAPI;
+    /** Returns an IConfiguration that can be used to set for application properties  */
+    get configuration(): IConfiguration | null;
+    private stopAudio;
+    private onPartialResultsCallback;
+    private onFinalResultsCallback;
+    private onCommandResultsCallback;
+    private interfaceCommand;
+    private onErrorCallback;
+    private onIdleMicCallback;
+    private onStateChangeCallback;
+    private onSocketFinalResult;
+    private onSessionEventCallback;
+    private onMicrophoneOnErrorCallback;
+    private createSDKConfig;
+    private createWorker;
+    private handleBeforeUnloadEvent;
+    private handleStorageChangeEvent;
+}

package/dist/AugnitoMobile.d.ts

@@ -0,0 +1,13 @@
+import { MobileClient } from './client/MobileClient';
+export declare class AugnitoMobile {
+    private _mobileClient;
+    /** Callback when a mobile client is requesting to connect */
+    onConnectionRequest?: () => void;
+    /** Callback when a mobile client has scanned the QR Code */
+    onMobileScan?: () => void;
+    constructor(_mobileClient: MobileClient);
+    dispose(): void;
+    stopMobileMicConnection(): void;
+    private onConnectionRequestCallback;
+    private onMobileScanCallback;
+}

package/dist/api/BaseAPI.d.ts

@@ -0,0 +1,32 @@
+export interface BaseResult {
+    Status: number;
+    ErrorMessage: string;
+    Data: {
+        StatusMessage: string;
+    };
+}
+export interface GetCommonPersonalisationRequest {
+    SubscriptionCode: string;
+    AccessKey: string;
+    SmId: string;
+}
+export interface GetCommonAccountInfoRequest {
+    SubscriptionCode: string;
+    AccessKey: string;
+}
+export interface GetVocabularyRequest extends GetCommonPersonalisationRequest {
+    UserCode: string;
+}
+export interface GetFormattingRequest extends GetCommonPersonalisationRequest {
+    UserTag: string;
+}
+export interface GetMedicineOrderingRequest extends GetCommonAccountInfoRequest {
+    UserTag: string;
+}
+export interface Edge {
+    PK: string;
+    SK: string;
+}
+export declare abstract class BaseAPI {
+    protected makePostRequest<R>(request: R, url: string): Promise<BaseResult | string>;
+}

package/dist/api/FactoryAPI.d.ts

@@ -0,0 +1,25 @@
+import { MacrosAPI } from './Macros/MacrosAPI';
+import { VocabularyAPI } from './Vocabulary/VocabularyAPI';
+import { NotificationClient } from '../client/NotificationClient';
+import { FormattingAPI } from './Formatting/FormattingAPI';
+import { MedicineOrderingAPI } from './MedicineOrdering/MedicineOrderingAPI';
+export declare class FactoryAPI {
+    private _accountCode;
+    private _accessKey;
+    private _server;
+    private _userTag;
+    private _lmid;
+    private _deviceId;
+    private _sourceApp;
+    private _enableLogs;
+    private _notificationClient;
+    constructor(_accountCode: string, _accessKey: string, _server: string, _userTag: string, _lmid: string, _deviceId: string | undefined, _sourceApp: string, _enableLogs: boolean, _notificationClient: NotificationClient);
+    /**
+     * Creates a client to interact with the MacrosAPI
+     * @returns The MacrosAPI client
+     */
+    getMacrosAPI(): MacrosAPI;
+    getMedicineOrderingAPI(): MedicineOrderingAPI;
+    getFormattingAPI(): FormattingAPI;
+    getVocabularyAPI(notifSubscribedInOtherWindow?: boolean): VocabularyAPI;
+}

package/dist/api/Formatting/FormattingAPI.d.ts

@@ -0,0 +1,15 @@
+import { BaseAPI } from '../BaseAPI';
+import { AugnitoFormattingConfig } from '../../config/AugnitoFormattingConfig';
+import { FormattingResult, RemoveFormattingRequest, UpsertFormattingRequest, UserFormattingRequest } from './FormattingModels';
+export declare class FormattingAPI extends BaseAPI {
+    private _config;
+    private _logTag;
+    private _baseUrl;
+    constructor(_config: AugnitoFormattingConfig);
+    private getURL;
+    getFormatting(request: UserFormattingRequest): Promise<FormattingResult | string>;
+    upsertFormatting(request: UpsertFormattingRequest): Promise<FormattingResult | string>;
+    removeFormatting(request: RemoveFormattingRequest): Promise<FormattingResult | string>;
+    private log;
+    private getGetCommonModel;
+}