@hailer/app-sdk 1.0.3 → 2.0.0-beta-2

package/lib/hailer-api.d.ts

@@ -1,9 +1,8 @@
 import { UserApi } from './modules/user';
 import { ActivityApi } from './modules/activity';
 import { WorkspaceApi } from './modules/workspace';
-import { HailerApiInfo, HailerSettings, HailerSignal } from './types';
+import { ApiInfo, Settings, Signal } from './types';
 import { Ui } from './modules/ui';
-import { Process } from './modules/process';
 import { HailerPublicApi } from './modules/public';
 import { WorkflowApi } from './modules/workflow';
 import { AppApi } from './modules/app';
@@ -20,23 +19,13 @@ export interface Options {
     /** Callback called on app init and when permissions have changed */
     permissions?: () => void;
     /** Callback called on app init and when settings have changed */
-    settings?: (data: HailerSettings) => void;
+    settings?: (data: Settings) => void;
     /** Callback called on app init and when config has changed */
     config?: (config: any) => void;
     /** Will be called each time a subscribed signal is emitted from Hailer frontend. To subscribe to signals, add them to options.subscribedSignals[] */
-    signals?: (signal: HailerSignal) => void;
+    signals?: (signal: Signal) => void;
     /** Urls the sdk is allowed to connect to. Defaults to all Hailer instances*/
     allowedUrls?: string[];
-    /**
-     * Optional signal filter, passes all signals by default
-     *
-     * Example:
-     *
-     *     subscribedSignals: ['activity.create', 'activity.update']
-     */
-    subscribedSignals?: string[];
-    /** Api version to be used in the app by default */
-    apiVersion?: 1;
     /** Public backend Api url. Defaults to https://api.hailer.com */
     publicBackendUrl?: string;
 }
@@ -47,7 +36,6 @@ export declare class HailerApi {
     activity: ActivityApi;
     insight: InsightApi;
     workspace: WorkspaceApi;
-    process: Process;
     workflow: WorkflowApi;
     permission: PermissionApi;
     product: ProductApi;
@@ -61,10 +49,7 @@ export declare class HailerApi {
     /** If set it indicates that app is locked to a specific workspaceId */
     private workspaceId?;
     private client;
-    private apiVersion;
-    private settings?;
     private config?;
-    private subscribedSignals?;
     private timer?;
     /**
      * Hailer API state
@@ -83,6 +68,5 @@ export declare class HailerApi {
      */
     constructor(options?: Options);
     private createEventListener;
-    info(): HailerApiInfo;
-    request(op: string, args: any[]): Promise<any>;
+    info(): ApiInfo;
 }

package/lib/hailer-api.js

@@ -0,0 +1,147 @@
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { Client } from '@wishcore/wish-rpc';
+import { User } from './modules/user';
+import { Activity } from './modules/activity';
+import { Network } from './modules/network';
+import { Ui } from './modules/ui';
+import { Insight } from './modules/insight';
+import { Process } from './modules/process';
+import { DEFAULT_ALLOWED_URLS, DEFAULT_API_VERSION } from './constants';
+var HailerApi = /** @class */ (function () {
+    /**
+     * Create a Hailer API client for inteacting with Hailer. **NOTE** This only works when inside Hailer.
+     *
+     * This should be run after window is initialized for example in ***onMount*** in Svelte or in ***useEffect*** in React
+     */
+    function HailerApi(options) {
+        if (options === void 0) { options = {}; }
+        var _this = this;
+        var _a, _b, _c, _d;
+        this.options = options;
+        var allowedUrls = (_a = options.allowedUrls) !== null && _a !== void 0 ? _a : DEFAULT_ALLOWED_URLS;
+        this.apiVersion = (_b = options.apiVersion) !== null && _b !== void 0 ? _b : DEFAULT_API_VERSION;
+        this.subscribedSignals = options.subscribedSignals;
+        this.client = new Client(function (msg) {
+            if (_this.hostUrl) {
+                parent.postMessage(JSON.stringify(msg), _this.hostUrl);
+            }
+        });
+        this.user = new User(this.client, this.apiVersion);
+        this.activity = new Activity(this.client, this.apiVersion);
+        this.insight = new Insight(this.client, this.apiVersion);
+        this.network = new Network(this.client, this.apiVersion);
+        this.process = new Process(this.client, this.apiVersion);
+        this.ui = new Ui(this.client, this.apiVersion);
+        var registerMessage = JSON.stringify({ op: 'register', args: [] });
+        // If we are not in Iframe set location to outside, else wait 100ms for response to register to check if we are in Hailer
+        if (window.location === window.parent.location) {
+            (_d = (_c = this.options).outside) === null || _d === void 0 ? void 0 : _d.call(_c);
+        }
+        else {
+            // if in a frame, try register to Hailer by sending register to all allowed urls
+            allowedUrls.forEach(function (url) { return parent.postMessage(registerMessage, url); });
+            this.timer = setTimeout(function () { var _a, _b; return (_b = (_a = _this.options).outside) === null || _b === void 0 ? void 0 : _b.call(_a); }, 100);
+        }
+        this.createEventListener();
+    }
+    HailerApi.prototype.createEventListener = function () {
+        var _this = this;
+        window.addEventListener('message', function (event) {
+            var _a, _b;
+            var data = event.data;
+            try {
+                var msg = JSON.parse(data);
+                if (msg.op === 'register') {
+                    clearTimeout(_this.timer);
+                    _this.appId = msg.data.appId;
+                    // Set host url now that we have a response
+                    _this.hostUrl = event.origin;
+                    // Register listeners for config and settings
+                    _this.client.request("v".concat(_this.apiVersion, ".ui.settings"), [], function (error, data, end) {
+                        var _a, _b;
+                        if (error) {
+                            console.log('ui.settings error:', error, data);
+                            return;
+                        }
+                        (_b = (_a = _this.options).settings) === null || _b === void 0 ? void 0 : _b.call(_a, data);
+                    });
+                    _this.client.request("v".concat(_this.apiVersion, ".config"), [], function (error, data, end) {
+                        var _a, _b;
+                        if (error) {
+                            console.log('config error:', error, data);
+                            return;
+                        }
+                        (_b = (_a = _this.options).config) === null || _b === void 0 ? void 0 : _b.call(_a, data);
+                    });
+                    // Register subscribed signals
+                    if (_this.subscribedSignals) {
+                        _this.client.request("v".concat(_this.apiVersion, ".signals"), [_this.subscribedSignals], function (error, data, end) {
+                            var _a, _b;
+                            if (error) {
+                                console.log('signals error:', error, data);
+                                return;
+                            }
+                            if (data) {
+                                (_b = (_a = _this.options).signals) === null || _b === void 0 ? void 0 : _b.call(_a, data);
+                            }
+                        });
+                    }
+                    // Call connected callback
+                    (_b = (_a = _this.options).connected) === null || _b === void 0 ? void 0 : _b.call(_a);
+                }
+                _this.client.messageReceived(msg);
+            }
+            catch (error) {
+                console.error(error);
+            }
+        });
+    };
+    // TODO: This is here for development and debugging, might be removed later
+    HailerApi.prototype.request = function (op, args) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.requestAsync(op, args)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return HailerApi;
+}());
+export { HailerApi };

package/lib/{src/index.d.ts → index.js}

@@ -1,2 +1,3 @@
 export { HailerApi } from './hailer-api';
+export { HailerApiPublic } from './public-api';
 export * from './types';

package/lib/modules/activity/kanban.js

@@ -0,0 +1,88 @@
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var Kanban = /** @class */ (function () {
+    function Kanban(client, apiVersion) {
+        this.client = client;
+        this.apiVersion = apiVersion;
+    }
+    /**
+     * Lists all activities in a kanban grouped by phases
+     *
+     * @param processId the id of the process the kanban relates to
+     * @param options object containing apiVersion option and requestOptions to be passed to the backend endpoint
+     *
+     * @returns activities in kanban list format
+     */
+    Kanban.prototype.list = function (processId, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.client.requestAsync("v".concat((_a = options === null || options === void 0 ? void 0 : options.apiVersion) !== null && _a !== void 0 ? _a : this.apiVersion, ".activity.kanban.list"), [processId, options === null || options === void 0 ? void 0 : options.requestOptions])];
+                    case 1:
+                        res = _b.sent();
+                        return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    /**
+     * Loads a single activity in kanban format
+     *
+     *  @param activityId activityId of the wanted activity
+     *  @param options object containing apiVersion option
+     *
+     *  @returns activity in kanban format
+     */
+    Kanban.prototype.load = function (activityId, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.client.requestAsync("v".concat((_a = options.apiVersion) !== null && _a !== void 0 ? _a : this.apiVersion, ".activity.kanban.load"), [activityId])];
+                    case 1:
+                        res = _b.sent();
+                        return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    return Kanban;
+}());
+export { Kanban };

package/lib/modules/activity.d.ts

@@ -1,5 +1,5 @@
 import { Client } from '@wishcore/wish-rpc';
-import { ActivityCreateOptions, ActivityListOptions, Activity } from '../types';
+import { ActivityCreateOptions, ActivityListOptions, Activity, ActivityFieldUpdateValue, ActivityUpdateOptions, ActivityFieldValue } from '../types';
 import { Kanban } from './activity/kanban';
 export declare class ActivityApi {
     private client;
@@ -33,30 +33,17 @@ export declare class ActivityApi {
     /**
      * Creates activities
      *
-     * @param processId The process where the activity is created
-     * @param activities new activities as objects
-     * @param activities.name name of the activity
-     * @param activities.fields fields of the activity
-     * @param options ActivityCreateOptions
-     *
      * @throws {HailerError} if request is incorrect
      */
-    create(processId: string, activities: {
-        name: string;
+    create(workflowId: string | undefined, activities: {
+        name?: string;
         fields?: {
-            [id: string]: string | number;
+            [id: string]: ActivityFieldValue;
         };
     }[], options?: ActivityCreateOptions): Promise<Activity[]>;
     /**
      * Updates activites
      *
-     * Each activity has the following parameters
-     * @param activities updated activity objects of an activity to edit
-     * @param activities.name New name of the activity
-     * @param activities.fields change values of fields, null removes current value
-     * @param activities.phaseId New phase of the activity
-     * @param options
-     *
      * @returns The number of updated activities
      *
      * @throws {HailerError} if request is incorrect
@@ -65,10 +52,10 @@ export declare class ActivityApi {
         _id: string;
         name?: string;
         fields?: {
-            [id: string]: string | number | null;
+            [id: string]: ActivityFieldUpdateValue;
         };
         phaseId?: string;
-    }[], options: any): Promise<number>;
+    }[], options?: ActivityUpdateOptions): Promise<number>;
     /**
      * Removes activities
      *

package/lib/modules/activity.js

@@ -0,0 +1,170 @@
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { HailerError } from '../types';
+var Activity = /** @class */ (function () {
+    function Activity(client, apiVersion) {
+        this.client = client;
+        this.apiVersion = apiVersion;
+    }
+    /**
+     * Lists all activities from the specified process and phase
+     *
+     * @param processId process from current network
+     * @param phaseId phase in the process specified in processId
+     * @param options options with apiVersion and requestOptions, default values can be found in api.hailer.com/docs v3.activity.list
+     *
+     * @returns List of Hailer activities from process and phase filtered with supplied options
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    Activity.prototype.list = function (processId, phaseId, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var res, error_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.client.requestAsync("v".concat((_a = options === null || options === void 0 ? void 0 : options.apiVersion) !== null && _a !== void 0 ? _a : this.apiVersion, ".activity.list"), [processId, phaseId, options === null || options === void 0 ? void 0 : options.requestOptions])];
+                    case 1:
+                        res = _b.sent();
+                        return [2 /*return*/, res.activities];
+                    case 2:
+                        error_1 = _b.sent();
+                        throw new HailerError(error_1);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Gets single activity
+     *
+     * @param activityId activity Id of the process specified in processId
+     * @param processId Process where the activityId is
+     * @param phaseId Phase where the activityId is in process specified by processId
+     * @param options options containing apiVersion
+     *
+     * @returns Hailer activity information
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    Activity.prototype.get = function (activityId, processId, phaseId, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var res, error_2;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.client.requestAsync("v".concat((_a = options === null || options === void 0 ? void 0 : options.apiVersion) !== null && _a !== void 0 ? _a : this.apiVersion, ".activity.list"), [processId, phaseId])];
+                    case 1:
+                        res = _b.sent();
+                        return [2 /*return*/, res.activities.find(function (activity) { return activity._id === activityId; })];
+                    case 2:
+                        error_2 = _b.sent();
+                        throw new HailerError(error_2);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Creates an activity
+     *
+     * @param processId The process where the activity is created
+     * @param activity Attributes of the new activity
+     * @param options optional options with apiVersion and requestOptions to be passed to the backend endpoint
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    Activity.prototype.create = function (processId, activities, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var res, error_3;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.client.requestAsync("v".concat((_a = options === null || options === void 0 ? void 0 : options.apiVersion) !== null && _a !== void 0 ? _a : this.apiVersion, ".activity.create"), [processId, activities])];
+                    case 1:
+                        res = _b.sent();
+                        return [2 /*return*/, res];
+                    case 2:
+                        error_3 = _b.sent();
+                        throw new HailerError(error_3);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Updates an activity
+     *
+     * @param _id Id of an activity to edit
+     * @param name New name of the activity
+     * @param fields change values of fields, null removes current value
+     * @param phaseId New phase of the activity
+     * @param options options containing apiVersion
+     *
+     * @returns The number of updated activities
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    Activity.prototype.update = function (activity, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var res, error_4;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.client.requestAsync("v".concat((_a = options === null || options === void 0 ? void 0 : options.apiVersion) !== null && _a !== void 0 ? _a : this.apiVersion, ".activity.update"), [activity])];
+                    case 1:
+                        res = _b.sent();
+                        return [2 /*return*/, res];
+                    case 2:
+                        error_4 = _b.sent();
+                        throw new HailerError(error_4);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return Activity;
+}());
+export { Activity };

package/lib/modules/app.d.ts

@@ -1,5 +1,5 @@
 import { Client } from '@wishcore/wish-rpc';
-import { HailerAppConfig, ProductVersion, Version } from '../types';
+import { Config, ProductVersion, Version } from '../types';
 /**
  * This class is used to access Hailer public API even when the app is outside of Hailer
  */
@@ -19,7 +19,9 @@ export declare class AppApi {
     };
     constructor(client: Client);
     config: {
-        update: (appId: string | undefined, config: HailerAppConfig) => Promise<void>;
+        update: (config: Config, option?: {
+            appId?: string;
+        }) => Promise<void>;
     };
     /**
      * Check if product is installed

package/lib/modules/insight.d.ts

@@ -27,7 +27,6 @@ export declare class InsightApi {
     /**
      * Get Insight data
      *
-     *
      * @returns data from the Insight
      *
      * @throws {HailerError} if request is incorrect

package/lib/modules/insight.js

@@ -0,0 +1,73 @@
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { HailerError } from '../types';
+var Insight = /** @class */ (function () {
+    function Insight(client, apiVersion) {
+        this.client = client;
+        this.apiVersion = apiVersion;
+    }
+    /**
+     * Get Insight data
+     *
+     * @param insightId the id of the Insight the data is fetched from
+     * @param options object containing apiVersion option
+     *
+     * @returns data from the Insight
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    Insight.prototype.data = function (insightId, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var error_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.client.requestAsync("v".concat((_a = options === null || options === void 0 ? void 0 : options.apiVersion) !== null && _a !== void 0 ? _a : this.apiVersion, ".insight.data"), [insightId])];
+                    case 1: return [2 /*return*/, _b.sent()];
+                    case 2:
+                        error_1 = _b.sent();
+                        throw new HailerError(error_1);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return Insight;
+}());
+export { Insight };