@wiotp/sdk 0.4.2 → 0.6.2

package/dist/api/ApiClient.js

@@ -0,0 +1,508 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _btoa = _interopRequireDefault(require("btoa"));
+
+var _formData = _interopRequireDefault(require("form-data"));
+
+var _loglevel = _interopRequireDefault(require("loglevel"));
+
+var _util = require("../util");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var ApiClient =
+/*#__PURE__*/
+function () {
+  function ApiClient(config) {
+    _classCallCheck(this, ApiClient);
+
+    this.log = _loglevel["default"];
+    this.log.setDefaultLevel(config.options.logLevel);
+    this.config = config;
+    this.useLtpa = this.config.auth && this.config.auth.useLtpa;
+    this.log.debug("[ApiClient:constructor] ApiClient initialized for " + this.config.getApiBaseUri());
+  } //  e.g. [{name: true}, {description: false}] => -name,description
+
+
+  _createClass(ApiClient, [{
+    key: "parseSortSpec",
+    value: function parseSortSpec(sortSpec) {
+      return sortSpec ? sortSpec.map(function (s) {
+        var e = Object.entries(s)[0];
+        return "".concat(e[1] ? '-' : '').concat(e[0]);
+      }).join(',') : undefined;
+    }
+  }, {
+    key: "callApi",
+    value: function callApi(method, expectedHttpCode, expectJsonContent, paths, body, params) {
+      var _this = this;
+
+      return new _bluebird["default"](function (resolve, reject) {
+        var uri = _this.config.getApiBaseUri();
+
+        if (Array.isArray(paths)) {
+          for (var i = 0, l = paths.length; i < l; i++) {
+            uri += '/' + paths[i];
+          }
+        }
+
+        var xhrConfig = {
+          url: uri,
+          method: method,
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          validateStatus: function validateStatus(status) {
+            if (Array.isArray(expectedHttpCode)) {
+              return expectedHttpCode.includes(status);
+            } else {
+              return status === expectedHttpCode;
+            }
+          }
+        };
+
+        if (_this.useLtpa) {
+          xhrConfig.withCredentials = true;
+        } else {
+          xhrConfig.headers['Authorization'] = 'Basic ' + (0, _btoa["default"])(_this.config.auth.key + ':' + _this.config.auth.token);
+        }
+
+        if (body) {
+          xhrConfig.data = body;
+        }
+
+        if (params) {
+          xhrConfig.params = params;
+        }
+
+        function transformResponse(response) {
+          if (expectJsonContent && !(_typeof(response.data) === 'object')) {
+            try {
+              resolve(JSON.parse(response.data));
+            } catch (e) {
+              reject(e);
+            }
+          } else {
+            resolve(response.data);
+          }
+        }
+
+        _this.log.debug("[ApiClient:transformResponse] " + xhrConfig);
+
+        (0, _axios["default"])(xhrConfig).then(transformResponse, reject);
+      });
+    }
+  }, {
+    key: "getOrganizationDetails",
+    value: function getOrganizationDetails() {
+      this.log.debug("[ApiClient] getOrganizationDetails()");
+      return this.callApi('GET', 200, true, null, null);
+    }
+  }, {
+    key: "getServiceStatus",
+    value: function getServiceStatus() {
+      this.log.debug("[ApiClient] getServiceStatus()");
+      return this.callApi('GET', 200, true, ['service-status'], null);
+    } //Usage Management
+
+  }, {
+    key: "getActiveDevices",
+    value: function getActiveDevices(start, end, detail) {
+      this.log.debug("[ApiClient] getActiveDevices(" + start + ", " + end + ")");
+      detail = detail | false;
+      var params = {
+        start: start,
+        end: end,
+        detail: detail
+      };
+      return this.callApi('GET', 200, true, ['usage', 'active-devices'], null, params);
+    }
+  }, {
+    key: "getHistoricalDataUsage",
+    value: function getHistoricalDataUsage(start, end, detail) {
+      this.log.debug("[ApiClient] getHistoricalDataUsage(" + start + ", " + end + ")");
+      detail = detail | false;
+      var params = {
+        start: start,
+        end: end,
+        detail: detail
+      };
+      return this.callApi('GET', 200, true, ['usage', 'historical-data'], null, params);
+    }
+  }, {
+    key: "getDataUsage",
+    value: function getDataUsage(start, end, detail) {
+      this.log.debug("[ApiClient] getDataUsage(" + start + ", " + end + ")");
+      detail = detail | false;
+      var params = {
+        start: start,
+        end: end,
+        detail: detail
+      };
+      return this.callApi('GET', 200, true, ['usage', 'data-traffic'], null, params);
+    } //client connectivity status
+
+  }, {
+    key: "getConnectionStates",
+    value: function getConnectionStates() {
+      this.log.debug("[ApiClient] getConnectionStates() - client connectivity");
+      return this.callApi('GET', 200, true, ["clientconnectionstates"], null);
+    }
+  }, {
+    key: "getConnectionState",
+    value: function getConnectionState(id) {
+      this.log.debug("[ApiClient] getConnectionState() - client connectivity");
+      return this.callApi('GET', 200, true, ["clientconnectionstates/" + id], null);
+    }
+  }, {
+    key: "getConnectedClientsConnectionStates",
+    value: function getConnectedClientsConnectionStates() {
+      this.log.debug("[ApiClient] getConnectedClientsConnectionStates() - client connectivity");
+      return this.callApi('GET', 200, true, ["clientconnectionstates?connectionStatus=connected"], null);
+    }
+  }, {
+    key: "getRecentConnectionStates",
+    value: function getRecentConnectionStates(date) {
+      this.log.debug("[ApiClient] getRecentConnectionStates() - client connectivity");
+      return this.callApi('GET', 200, true, ["clientconnectionstates?connectedAfter=" + date], null);
+    }
+  }, {
+    key: "getCustomConnectionState",
+    value: function getCustomConnectionState(query) {
+      this.log.debug("[ApiClient] getCustomConnectionStates() - client connectivity");
+      return this.callApi('GET', 200, true, ["clientconnectionstates" + query], null);
+    } //bulk apis
+
+  }, {
+    key: "getAllDevices",
+    value: function getAllDevices(params) {
+      this.log.debug("[ApiClient] getAllDevices() - BULK");
+      return this.callApi('GET', 200, true, ["bulk", "devices"], null, params);
+    }
+    /**
+    * Gateway Access Control (Beta)
+    * The methods in this section follow the documentation listed under the link:
+    * https://console.ng.bluemix.net/docs/services/IoT/gateways/gateway-access-control.html#gateway-access-control-beta-
+    * Involves the following sections from the above mentioned link:
+    * Assigning a role to a gateway
+    * Adding devices to and removing devices from a resource group
+    * Finding a resource group
+    * Querying a resource group
+    * Creating and deleting a resource group
+    * Updating group properties
+    * Retrieving and updating device properties
+    * 
+    */
+    //getGatewayGroup(gatewayId)
+    //updateDeviceRoles(deviceId, roles[])
+    //getAllDevicesInGropu(groupId)
+    //addDevicesToGroup(groupId, deviceList[])
+    //removeDevicesFromGroup(groupId, deviceList[])
+
+  }, {
+    key: "getGroupIdsForDevice",
+    value: function getGroupIdsForDevice(deviceId) {
+      this.log.debug("[ApiClient] getGroupIdsForDevice(" + deviceId + ")");
+      return this.callApi('GET', 200, true, ['authorization', 'devices', deviceId], null);
+    }
+  }, {
+    key: "updateDeviceRoles",
+    value: function updateDeviceRoles(deviceId, roles) {
+      this.log.debug("[ApiClient] updateDeviceRoles(" + deviceId + "," + roles + ")");
+      return this.callApi('PUT', 200, false, ['authorization', 'devices', deviceId, 'roles'], roles);
+    }
+  }, {
+    key: "getAllDevicesInGroup",
+    value: function getAllDevicesInGroup(groupId) {
+      this.log.debug("[ApiClient] getAllDevicesInGropu(" + groupId + ")");
+      return this.callApi('GET', 200, true, ['bulk', 'devices', groupId], null);
+    }
+  }, {
+    key: "addDevicesToGroup",
+    value: function addDevicesToGroup(groupId, deviceList) {
+      this.log.debug("[ApiClient] addDevicesToGroup(" + groupId + "," + deviceList + ")");
+      return this.callApi('PUT', 200, false, ['bulk', 'devices', groupId, "add"], deviceList);
+    }
+  }, {
+    key: "removeDevicesFromGroup",
+    value: function removeDevicesFromGroup(groupId, deviceList) {
+      this.log.debug("[ApiClient] removeDevicesFromGroup(" + groupId + "," + deviceList + ")");
+      return this.callApi('PUT', 200, false, ['bulk', 'devices', groupId, "remove"], deviceList);
+    } // https://console.ng.bluemix.net/docs/services/IoT/gateways/gateway-access-control.html
+    // Finding a Resource Group
+    // getGatewayGroups()
+    // Querying a resource group
+    // getUniqueDevicesInGroup(groupId)
+    // getUniqueGatewayGroup(groupId)
+    // Creating and deleting a resource group
+    // createGatewayGroup(groupName)
+    // deleteGatewayGroup(groupId)
+    // Retrieving and updating device properties
+    // getGatewayGroupProperties()
+    // getDeviceRoles(deviceId)
+    // updateGatewayProperties(gatewayId,control_props)
+    // updateDeviceControlProperties(deviceId, withroles)
+    // Finding a Resource Group
+
+  }, {
+    key: "getAllGroups",
+    value: function getAllGroups() {
+      this.log.debug("[ApiClient] getAllGroups()");
+      return this.callApi('GET', 200, true, ['groups'], null);
+    } // Querying a resource group
+    // Get unique identifiers of the members of the resource group
+
+  }, {
+    key: "getAllDeviceIdsInGroup",
+    value: function getAllDeviceIdsInGroup(groupId) {
+      this.log.debug("[ApiClient] getAllDeviceIdsInGroup(" + groupId + ")");
+      return this.callApi('GET', 200, true, ['bulk', 'devices', groupId, "ids"], null);
+    } // properties of the resource group
+
+  }, {
+    key: "getGroup",
+    value: function getGroup(groupId) {
+      this.log.debug("[ApiClient] getGroup(" + groupId + ")");
+      return this.callApi('GET', 200, true, ['groups', groupId], null);
+    } // Creating and deleting a resource group
+    // Create a Resource Group
+
+  }, {
+    key: "createGroup",
+    value: function createGroup(groupInfo) {
+      this.log.debug("[ApiClient] createGroup()");
+      return this.callApi('POST', 201, true, ['groups'], groupInfo);
+    } // Delete a Resource Group
+
+  }, {
+    key: "deleteGroup",
+    value: function deleteGroup(groupId) {
+      this.log.debug("[ApiClient] deleteGroup(" + groupId + ")");
+      return this.callApi('DELETE', 200, false, ['groups', groupId], null);
+    } // Retrieving and updating device properties
+    // Get the ID of the devices group of a gateway
+
+  }, {
+    key: "getAllDeviceAccessControlProperties",
+    value: function getAllDeviceAccessControlProperties() {
+      this.log.debug("[ApiClient] getAllDeviceAccessControlProperties()");
+      return this.callApi('GET', 200, true, ['authorization', 'devices'], null);
+    } // Get standard role of a gateway
+
+  }, {
+    key: "getDeviceAccessControlProperties",
+    value: function getDeviceAccessControlProperties(deviceId) {
+      this.log.debug("[ApiClient] getDeviceAccessControlProperties(" + deviceId + ")");
+      return this.callApi('GET', 200, true, ['authorization', 'devices', deviceId, 'roles'], null);
+    } // Update device properties without affecting the access control properties
+
+  }, {
+    key: "updateDeviceAccessControlProperties",
+    value: function updateDeviceAccessControlProperties(deviceId, deviceProps) {
+      this.log.debug("[ApiClient] updateDeviceAccessControlProperties(" + deviceId + ")");
+      return this.callApi('PUT', 200, true, ['authorization', 'devices', deviceId], deviceProps);
+    } // Assign a standard role to a gateway
+
+  }, {
+    key: "updateDeviceAccessControlPropertiesWithRoles",
+    value: function updateDeviceAccessControlPropertiesWithRoles(deviceId, devicePropsWithRoles) {
+      this.log.debug("[ApiClient] updateDeviceAccessControlPropertiesWithRoles(" + deviceId + "," + devicePropsWithRoles + ")");
+      return this.callApi('PUT', 200, true, ['authorization', 'devices', deviceId, 'withroles'], devicePropsWithRoles);
+    } // Duplicating updateDeviceRoles(deviceId, roles) for Gateway Roles
+
+  }, {
+    key: "updateGatewayRoles",
+    value: function updateGatewayRoles(gatewayId, roles) {
+      this.log.debug("[ApiClient] updateGatewayRoles(" + gatewayId + "," + roles + ")");
+      return this.callApi('PUT', 200, false, ['authorization', 'devices', gatewayId, 'roles'], roles);
+    } // Extending getAllGroups() to fetch individual Groups
+
+  }, {
+    key: "getGroups",
+    value: function getGroups(groupId) {
+      this.log.debug("[ApiClient] getGroups(" + groupId + ")");
+      return this.callApi('GET', 200, true, ['groups', groupId], null);
+    }
+  }, {
+    key: "callFormDataApi",
+    value: function callFormDataApi(method, expectedHttpCode, expectJsonContent, paths, body, params) {
+      var _this2 = this;
+
+      return new _bluebird["default"](function (resolve, reject) {
+        var uri = _this2.config.getApiBaseUri();
+
+        if (Array.isArray(paths)) {
+          for (var i = 0, l = paths.length; i < l; i++) {
+            uri += '/' + paths[i];
+          }
+        }
+
+        var xhrConfig = {
+          url: uri,
+          method: method,
+          headers: {
+            'Content-Type': 'multipart/form-data'
+          }
+        };
+
+        if (_this2.useLtpa) {
+          xhrConfig.withCredentials = true;
+        } else {
+          xhrConfig.headers['Authorization'] = 'Basic ' + (0, _btoa["default"])(_this2.apiKey + ':' + _this2.apiToken);
+        }
+
+        if (body) {
+          xhrConfig.data = body;
+
+          if ((0, _util.isBrowser)()) {
+            xhrConfig.transformRequest = [function (data) {
+              var formData = new _formData["default"]();
+
+              if (xhrConfig.method == "POST") {
+                if (data.schemaFile) {
+                  var blob = new Blob([data.schemaFile], {
+                    type: "application/json"
+                  });
+                  formData.append('schemaFile', blob);
+                }
+
+                if (data.name) {
+                  formData.append('name', data.name);
+                }
+
+                if (data.schemaType) {
+                  formData.append('schemaType', 'json-schema');
+                }
+
+                if (data.description) {
+                  formData.append('description', data.description);
+                }
+              } else if (xhrConfig.method == "PUT") {
+                if (data.schemaFile) {
+                  var blob = new Blob([data.schemaFile], {
+                    type: "application/json",
+                    name: data.name
+                  });
+                  formData.append('schemaFile', blob);
+                }
+              }
+
+              return formData;
+            }];
+          }
+        }
+
+        if (params) {
+          xhrConfig.params = params;
+        }
+
+        function transformResponse(response) {
+          if (response.status === expectedHttpCode) {
+            if (expectJsonContent && !(_typeof(response.data) === 'object')) {
+              try {
+                resolve(JSON.parse(response.data));
+              } catch (e) {
+                reject(e);
+              }
+            } else {
+              resolve(response.data);
+            }
+          } else {
+            reject(new Error(method + " " + uri + ": Expected HTTP " + expectedHttpCode + " from server but got HTTP " + response.status + ". Error Body: " + JSON.stringify(response.data)));
+          }
+        }
+
+        _this2.log.debug("[ApiClient:transformResponse] " + xhrConfig);
+
+        if ((0, _util.isBrowser)()) {
+          (0, _axios["default"])(xhrConfig).then(transformResponse, reject);
+        } else {
+          var formData = null;
+          var config = {
+            url: uri,
+            method: method,
+            headers: {
+              'Content-Type': 'multipart/form-data'
+            },
+            auth: {
+              user: _this2.apiKey,
+              pass: _this2.apiToken
+            },
+            formData: {},
+            rejectUnauthorized: false
+          };
+
+          if (xhrConfig.method == "POST") {
+            formData = {
+              'schemaFile': {
+                'value': body.schemaFile,
+                'options': {
+                  'contentType': 'application/json',
+                  'filename': body.name
+                }
+              },
+              'schemaType': 'json-schema',
+              'name': body.name
+            };
+            config.formData = formData;
+          } else if (xhrConfig.method == "PUT") {
+            formData = {
+              'schemaFile': {
+                'value': body.schemaFile,
+                'options': {
+                  'contentType': 'application/json',
+                  'filename': body.name
+                }
+              }
+            };
+            config.formData = formData;
+          }
+
+          request(config, function optionalCallback(err, response, body) {
+            if (response.statusCode === expectedHttpCode) {
+              if (expectJsonContent && !(_typeof(response.data) === 'object')) {
+                try {
+                  resolve(JSON.parse(body));
+                } catch (e) {
+                  reject(e);
+                }
+              } else {
+                resolve(body);
+              }
+            } else {
+              reject(new Error(method + " " + uri + ": Expected HTTP " + expectedHttpCode + " from server but got HTTP " + response.statusCode + ". Error Body: " + err));
+            }
+          });
+        }
+      });
+    }
+  }, {
+    key: "invalidOperation",
+    value: function invalidOperation(message) {
+      return new _bluebird["default"](function (resolve, reject) {
+        resolve(message);
+      });
+    }
+  }]);
+
+  return ApiClient;
+}();
+
+exports["default"] = ApiClient;

package/dist/api/ApiErrors.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.handleError = exports.ServiceNotFound = exports.DestinationAlreadyExists = exports.InvalidServiceCredentials = exports.WiotpError = void 0;
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+
+function isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var WiotpError =
+/*#__PURE__*/
+function (_Error) {
+  _inherits(WiotpError, _Error);
+
+  function WiotpError(message, cause) {
+    var _this;
+
+    _classCallCheck(this, WiotpError);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(WiotpError).call(this, message));
+    _this.cause = cause;
+    _this.name = _this.constructor.name;
+    return _this;
+  }
+
+  return WiotpError;
+}(_wrapNativeSuper(Error));
+
+exports.WiotpError = WiotpError;
+
+var InvalidServiceCredentials =
+/*#__PURE__*/
+function (_WiotpError) {
+  _inherits(InvalidServiceCredentials, _WiotpError);
+
+  function InvalidServiceCredentials() {
+    _classCallCheck(this, InvalidServiceCredentials);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(InvalidServiceCredentials).apply(this, arguments));
+  }
+
+  return InvalidServiceCredentials;
+}(WiotpError);
+
+exports.InvalidServiceCredentials = InvalidServiceCredentials;
+
+var DestinationAlreadyExists =
+/*#__PURE__*/
+function (_WiotpError2) {
+  _inherits(DestinationAlreadyExists, _WiotpError2);
+
+  function DestinationAlreadyExists() {
+    _classCallCheck(this, DestinationAlreadyExists);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(DestinationAlreadyExists).apply(this, arguments));
+  }
+
+  return DestinationAlreadyExists;
+}(WiotpError);
+
+exports.DestinationAlreadyExists = DestinationAlreadyExists;
+
+var ServiceNotFound =
+/*#__PURE__*/
+function (_WiotpError3) {
+  _inherits(ServiceNotFound, _WiotpError3);
+
+  function ServiceNotFound() {
+    _classCallCheck(this, ServiceNotFound);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(ServiceNotFound).apply(this, arguments));
+  }
+
+  return ServiceNotFound;
+}(WiotpError);
+
+exports.ServiceNotFound = ServiceNotFound;
+
+var handleError = function handleError(err, errorMappings) {
+  if (err && err.response && err.response.data && err.response.data.exception && err.response.data.exception.id) {
+    if (errorMappings && errorMappings[err.response.data.exception.id]) {
+      throw new errorMappings[err.response.data.exception.id](err.response.data.message, err);
+    } else {
+      throw new WiotpError(err.response.data.message, err);
+    }
+  } else {
+    throw err;
+  }
+};
+
+exports.handleError = handleError;
+var _default = {
+  WiotpError: WiotpError,
+  InvalidServiceCredentials: InvalidServiceCredentials,
+  DestinationAlreadyExists: DestinationAlreadyExists,
+  ServiceNotFound: ServiceNotFound
+};
+exports["default"] = _default;