@wiotp/sdk 0.4.2 → 0.6.2

package/dist/api/StateClient.js

@@ -0,0 +1,738 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _loglevel = _interopRequireDefault(require("loglevel"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": 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 StateClient =
+/*#__PURE__*/
+function () {
+  function StateClient(apiClient) {
+    _classCallCheck(this, StateClient);
+
+    this.log = _loglevel["default"];
+    this.apiClient = apiClient;
+    this.draftMode = true; // Create an alias to the apiClient's methods that we use
+
+    this.callApi = this.apiClient.callApi.bind(this.apiClient);
+    this.parseSortSpec = this.apiClient.parseSortSpec.bind(this.apiClient);
+    this.callFormDataApi = this.apiClient.callFormDataApi.bind(this.apiClient);
+    this.invalidOperation = this.apiClient.invalidOperation.bind(this.apiClient);
+  }
+
+  _createClass(StateClient, [{
+    key: "workWithActive",
+    value: function workWithActive() {
+      this.draftMode = false;
+    }
+  }, {
+    key: "workWithDraft",
+    value: function workWithDraft() {
+      this.draftMode = true;
+    } // IM Device state API
+
+  }, {
+    key: "createSchema",
+    value: function createSchema(schemaContents, name, description) {
+      var body = {
+        'schemaFile': schemaContents,
+        'schemaType': 'json-schema',
+        'name': name
+      };
+
+      if (description) {
+        body.description = description;
+      }
+
+      var base = this.draftMode ? ["draft", "schemas"] : ["schemas"];
+      return this.callFormDataApi('POST', 201, true, base, body, null);
+    }
+  }, {
+    key: "getSchema",
+    value: function getSchema(schemaId) {
+      var base = this.draftMode ? ["draft", "schemas", schemaId] : ["schemas", schemaId];
+      return this.callApi('GET', 200, true, base);
+    }
+  }, {
+    key: "getActiveSchema",
+    value: function getActiveSchema(schemaId) {
+      return this.callApi('GET', 200, true, ["schemas", schemaId]);
+    }
+  }, {
+    key: "getSchemas",
+    value: function getSchemas() {
+      var base = this.draftMode ? ["draft", "schemas"] : ["schemas"];
+      return this.callApi('GET', 200, true, base);
+    }
+  }, {
+    key: "getActiveSchemas",
+    value: function getActiveSchemas() {
+      return this.callApi('GET', 200, true, ["schemas"]);
+    }
+  }, {
+    key: "updateSchema",
+    value: function updateSchema(schemaId, name, description) {
+      var body = {
+        "id": schemaId,
+        "name": name,
+        "description": description
+      };
+      var base = this.draftMode ? ["draft", "schemas", schemaId] : ["schemas", schemaId];
+      return this.callApi('PUT', 200, true, base, body);
+    }
+  }, {
+    key: "updateSchemaContent",
+    value: function updateSchemaContent(schemaId, schemaContents, filename) {
+      var body = {
+        'schemaFile': schemaContents,
+        'name': filename
+      };
+      var base = this.draftMode ? ["draft", "schemas", schemaId, "content"] : ["schemas", schemaId, "content"];
+      return this.callFormDataApi('PUT', 204, false, base, body, null);
+    }
+  }, {
+    key: "getSchemaContent",
+    value: function getSchemaContent(schemaId) {
+      var base = this.draftMode ? ["draft", "schemas", schemaId, "content"] : ["schemas", schemaId, "content"];
+      return this.callApi('GET', 200, true, base);
+    }
+  }, {
+    key: "getActiveSchemaContent",
+    value: function getActiveSchemaContent(schemaId) {
+      return this.callApi('GET', 200, true, ["schemas", schemaId, "content"]);
+    }
+  }, {
+    key: "deleteSchema",
+    value: function deleteSchema(schemaId) {
+      var base = this.draftMode ? ["draft", "schemas", schemaId] : ["schemas", schemaId];
+      return this.callApi('DELETE', 204, false, base, null);
+    }
+  }, {
+    key: "createEventType",
+    value: function createEventType(name, description, schemaId) {
+      var body = {
+        'name': name,
+        'description': description,
+        'schemaId': schemaId
+      };
+      var base = this.draftMode ? ["draft", "event", "types"] : ["event", "types"];
+      return this.callApi('POST', 201, true, base, JSON.stringify(body));
+    }
+  }, {
+    key: "getEventType",
+    value: function getEventType(eventTypeId) {
+      var base = this.draftMode ? ["draft", "event", "types", eventTypeId] : ["event", "types", eventTypeId];
+      return this.callApi('GET', 200, true, base);
+    }
+  }, {
+    key: "getActiveEventType",
+    value: function getActiveEventType(eventTypeId) {
+      return this.callApi('GET', 200, true, ["event", "types", eventTypeId]);
+    }
+  }, {
+    key: "deleteEventType",
+    value: function deleteEventType(eventTypeId) {
+      var base = this.draftMode ? ["draft", "event", "types", eventTypeId] : ["event", "types", eventTypeId];
+      return this.callApi('DELETE', 204, false, base);
+    }
+  }, {
+    key: "updateEventType",
+    value: function updateEventType(eventTypeId, name, description, schemaId) {
+      var body = {
+        "id": eventTypeId,
+        "name": name,
+        "description": description,
+        "schemaId": schemaId
+      };
+      var base = this.draftMode ? ["draft", "event", "types", eventTypeId] : ["event", "types", eventTypeId];
+      return this.callApi('PUT', 200, true, base, body);
+    }
+  }, {
+    key: "getEventTypes",
+    value: function getEventTypes() {
+      var base = this.draftMode ? ["draft", "event", "types"] : ["event", "types"];
+      return this.callApi('GET', 200, true, base);
+    }
+  }, {
+    key: "getActiveEventTypes",
+    value: function getActiveEventTypes() {
+      return this.callApi('GET', 200, true, ["event", "types"]);
+    }
+  }, {
+    key: "createPhysicalInterface",
+    value: function createPhysicalInterface(name, description) {
+      var body = {
+        'name': name,
+        'description': description
+      };
+      var base = this.draftMode ? ["draft", "physicalinterfaces"] : ["physicalinterfaces"];
+      return this.callApi('POST', 201, true, base, body);
+    }
+  }, {
+    key: "getPhysicalInterface",
+    value: function getPhysicalInterface(physicalInterfaceId) {
+      var base = this.draftMode ? ["draft", "physicalinterfaces", physicalInterfaceId] : ["physicalinterfaces", physicalInterfaceId];
+      return this.callApi('GET', 200, true, base);
+    }
+  }, {
+    key: "getActivePhysicalInterface",
+    value: function getActivePhysicalInterface(physicalInterfaceId) {
+      return this.callApi('GET', 200, true, ["physicalinterfaces", physicalInterfaceId]);
+    }
+  }, {
+    key: "deletePhysicalInterface",
+    value: function deletePhysicalInterface(physicalInterfaceId) {
+      var base = this.draftMode ? ["draft", "physicalinterfaces", physicalInterfaceId] : ["physicalinterfaces", physicalInterfaceId];
+      return this.callApi('DELETE', 204, false, base);
+    }
+  }, {
+    key: "updatePhysicalInterface",
+    value: function updatePhysicalInterface(physicalInterfaceId, name, description) {
+      var body = {
+        'id': physicalInterfaceId,
+        'name': name,
+        'description': description
+      };
+      var base = this.draftMode ? ["draft", "physicalinterfaces", physicalInterfaceId] : ["physicalinterfaces", physicalInterfaceId];
+      return this.callApi('PUT', 200, true, base, body);
+    }
+  }, {
+    key: "getPhysicalInterfaces",
+    value: function getPhysicalInterfaces() {
+      var base = this.draftMode ? ["draft", "physicalinterfaces"] : ["physicalinterfaces"];
+      return this.callApi('GET', 200, true, base);
+    }
+  }, {
+    key: "getActivePhysicalInterfaces",
+    value: function getActivePhysicalInterfaces() {
+      return this.callApi('GET', 200, true, ["physicalinterfaces"]);
+    }
+  }, {
+    key: "createPhysicalInterfaceEventMapping",
+    value: function createPhysicalInterfaceEventMapping(physicalInterfaceId, eventId, eventTypeId) {
+      var body = {
+        "eventId": eventId,
+        "eventTypeId": eventTypeId
+      };
+      var base = this.draftMode ? ["draft", "physicalinterfaces", physicalInterfaceId, "events"] : ["physicalinterfaces", physicalInterfaceId, "events"];
+      return this.callApi('POST', 201, true, base, body);
+    }
+  }, {
+    key: "getPhysicalInterfaceEventMappings",
+    value: function getPhysicalInterfaceEventMappings(physicalInterfaceId) {
+      var base = this.draftMode ? ["draft", "physicalinterfaces", physicalInterfaceId, "events"] : ["physicalinterfaces", physicalInterfaceId, "events"];
+      return this.callApi('GET', 200, true, base);
+    }
+  }, {
+    key: "getActivePhysicalInterfaceEventMappings",
+    value: function getActivePhysicalInterfaceEventMappings(physicalInterfaceId) {
+      return this.callApi('GET', 200, true, ["physicalinterfaces", physicalInterfaceId, "events"]);
+    }
+  }, {
+    key: "deletePhysicalInterfaceEventMapping",
+    value: function deletePhysicalInterfaceEventMapping(physicalInterfaceId, eventId) {
+      var base = this.draftMode ? ["draft", "physicalinterfaces", physicalInterfaceId, "events", eventId] : ["physicalinterfaces", physicalInterfaceId, "events", eventId];
+      return this.callApi('DELETE', 204, false, base);
+    }
+  }, {
+    key: "createLogicalInterface",
+    value: function createLogicalInterface(name, description, schemaId, alias) {
+      var body = {
+        'name': name,
+        'description': description,
+        'schemaId': schemaId
+      };
+
+      if (alias !== undefined) {
+        body.alias = alias;
+      }
+
+      var base = this.draftMode ? ["draft", "logicalinterfaces"] : ["applicationinterfaces"];
+      return this.callApi('POST', 201, true, base, body);
+    }
+  }, {
+    key: "getLogicalInterface",
+    value: function getLogicalInterface(logicalInterfaceId) {
+      var base = this.draftMode ? ["draft", "logicalinterfaces", logicalInterfaceId] : ["applicationinterfaces", logicalInterfaceId];
+      return this.callApi('GET', 200, true, base);
+    }
+  }, {
+    key: "getActiveLogicalInterface",
+    value: function getActiveLogicalInterface(logicalInterfaceId) {
+      return this.callApi('GET', 200, true, ["logicalinterfaces", logicalInterfaceId]);
+    }
+  }, {
+    key: "deleteLogicalInterface",
+    value: function deleteLogicalInterface(logicalInterfaceId) {
+      var base = this.draftMode ? ["draft", "logicalinterfaces", logicalInterfaceId] : ["applicationinterfaces", logicalInterfaceId];
+      return this.callApi('DELETE', 204, false, base);
+    }
+  }, {
+    key: "updateLogicalInterface",
+    value: function updateLogicalInterface(logicalInterfaceId, name, description, schemaId, alias) {
+      var body = {
+        "id": logicalInterfaceId,
+        "name": name,
+        "description": description,
+        "schemaId": schemaId
+      };
+
+      if (alias !== undefined) {
+        body.alias = alias;
+      }
+
+      var base = this.draftMode ? ["draft", "logicalinterfaces", logicalInterfaceId] : ["applicationinterfaces", logicalInterfaceId];
+      return this.callApi('PUT', 200, true, base, body);
+    }
+  }, {
+    key: "getLogicalInterfaces",
+    value: function getLogicalInterfaces(bookmark, limit, sort, name) {
+      var base = this.draftMode ? ["draft", "logicalinterfaces"] : ["logicalinterfaces"];
+
+      var _sort = this.parseSortSpec(sort);
+
+      return this.callApi('GET', 200, true, base, undefined, {
+        _bookmark: bookmark,
+        _limit: limit,
+        _sort: _sort,
+        name: name ? name : undefined
+      });
+    }
+  }, {
+    key: "getActiveLogicalInterfaces",
+    value: function getActiveLogicalInterfaces() {
+      return this.callApi('GET', 200, true, ["logicalinterfaces"]);
+    } // Application interface patch operation on draft version
+    // Acceptable operation id - validate-configuration, activate-configuration, list-differences
+
+  }, {
+    key: "patchOperationLogicalInterface",
+    value: function patchOperationLogicalInterface(logicalInterfaceId, operationId) {
+      var body = {
+        "operation": operationId
+      };
+
+      if (this.draftMode) {
+        switch (operationId) {
+          case 'validate-configuration':
+            return this.callApi('PATCH', 200, true, ["draft", "logicalinterfaces", logicalInterfaceId], body);
+            break;
+
+          case 'activate-configuration':
+            return this.callApi('PATCH', 202, true, ["draft", "logicalinterfaces", logicalInterfaceId], body);
+
+          case 'deactivate-configuration':
+            return this.callApi('PATCH', 202, true, ["draft", "logicalinterfaces", logicalInterfaceId], body);
+
+          case 'list-differences':
+            return this.callApi('PATCH', 200, true, ["draft", "logicalinterfaces", logicalInterfaceId], body);
+
+          default:
+            return this.callApi('PATCH', 200, true, ["draft", "logicalinterfaces", logicalInterfaceId], body);
+        }
+      } else {
+        return this.invalidOperation("PATCH operation not allowed on logical interface");
+      }
+    } // Application interface patch operation on active version
+    // Acceptable operation id - deactivate-configuration 
+
+  }, {
+    key: "patchOperationActiveLogicalInterface",
+    value: function patchOperationActiveLogicalInterface(logicalInterfaceId, operationId) {
+      var body = {
+        "operation": operationId
+      };
+
+      if (this.draftMode) {
+        return this.callApi('PATCH', 202, true, ["logicalinterfaces", logicalInterfaceId], body);
+      } else {
+        return this.invalidOperation("PATCH operation 'deactivate-configuration' not allowed on logical interface");
+      }
+    } // Create device type with physical Interface Id
+
+  }, {
+    key: "createDeviceType",
+    value: function createDeviceType(typeId, description, deviceInfo, metadata, classId, physicalInterfaceId) {
+      this.log.debug("[ApiClient] registerDeviceType(" + typeId + ", " + description + ", " + deviceInfo + ", " + metadata + ", " + classId + ", " + physicalInterfaceId + ")");
+      classId = classId || "Device";
+      var body = {
+        id: typeId,
+        classId: classId,
+        deviceInfo: deviceInfo,
+        description: description,
+        metadata: metadata,
+        physicalInterfaceId: physicalInterfaceId
+      };
+      return this.callApi('POST', 201, true, ['device', 'types'], JSON.stringify(body));
+    }
+  }, {
+    key: "createDeviceTypePhysicalInterfaceAssociation",
+    value: function createDeviceTypePhysicalInterfaceAssociation(typeId, physicalInterfaceId) {
+      var body = {
+        id: physicalInterfaceId
+      };
+
+      if (this.draftMode) {
+        return this.callApi('POST', 201, true, ['draft', 'device', 'types', typeId, 'physicalinterface'], JSON.stringify(body));
+      } else {
+        return this.callApi('PUT', 200, true, ['device', 'types', typeId], JSON.stringify({
+          physicalInterfaceId: physicalInterfaceId
+        }));
+      }
+    }
+  }, {
+    key: "getDeviceTypePhysicalInterfaces",
+    value: function getDeviceTypePhysicalInterfaces(typeId) {
+      if (this.draftMode) {
+        return this.callApi('GET', 200, true, ['draft', 'device', 'types', typeId, 'physicalinterface']);
+      } else {
+        return this.invalidOperation("GET Device type's physical interface is not allowed");
+      }
+    }
+  }, {
+    key: "getActiveDeviceTypePhysicalInterfaces",
+    value: function getActiveDeviceTypePhysicalInterfaces(typeId) {
+      return this.callApi('GET', 200, true, ['device', 'types', typeId, 'physicalinterface']);
+    }
+  }, {
+    key: "deleteDeviceTypePhysicalInterfaceAssociation",
+    value: function deleteDeviceTypePhysicalInterfaceAssociation(typeId) {
+      if (this.draftMode) {
+        return this.callApi('DELETE', 204, false, ['draft', 'device', 'types', typeId, 'physicalinterface']);
+      } else {
+        return this.invalidOperation("DELETE Device type's physical interface is not allowed");
+      }
+    }
+  }, {
+    key: "createDeviceTypeLogicalInterfaceAssociation",
+    value: function createDeviceTypeLogicalInterfaceAssociation(typeId, logicalInterfaceId) {
+      var body = {
+        'id': logicalInterfaceId
+      };
+      var base = this.draftMode ? ['draft', 'device', 'types', typeId, 'logicalinterfaces'] : ['device', 'types', typeId, 'applicationinterfaces'];
+      return this.callApi('POST', 201, true, base, body);
+    }
+  }, {
+    key: "getDeviceTypeLogicalInterfaces",
+    value: function getDeviceTypeLogicalInterfaces(typeId) {
+      var base = this.draftMode ? ['draft', 'device', 'types', typeId, 'logicalinterfaces'] : ['device', 'types', typeId, 'applicationinterfaces'];
+      return this.callApi('GET', 200, true, base);
+    }
+  }, {
+    key: "getActiveDeviceTypeLogicalInterfaces",
+    value: function getActiveDeviceTypeLogicalInterfaces(typeId) {
+      return this.callApi('GET', 200, true, ['device', 'types', typeId, 'logicalinterfaces']);
+    }
+  }, {
+    key: "createDeviceTypeLogicalInterfacePropertyMappings",
+    value: function createDeviceTypeLogicalInterfacePropertyMappings(typeId, logicalInterfaceId, mappings, notificationStrategy) {
+      var body = null,
+          base = null;
+
+      if (this.draftMode) {
+        body = {
+          "logicalInterfaceId": logicalInterfaceId,
+          "propertyMappings": mappings,
+          "notificationStrategy": "never"
+        };
+
+        if (notificationStrategy) {
+          body.notificationStrategy = notificationStrategy;
+        }
+
+        base = ['draft', 'device', 'types', typeId, 'mappings'];
+      } else {
+        body = {
+          "applicationInterfaceId": logicalInterfaceId,
+          "propertyMappings": mappings
+        };
+        base = ['device', 'types', typeId, 'mappings'];
+      }
+
+      return this.callApi('POST', 201, true, base, body);
+    }
+  }, {
+    key: "getDeviceTypePropertyMappings",
+    value: function getDeviceTypePropertyMappings(typeId) {
+      var base = this.draftMode ? ['draft', 'device', 'types', typeId, 'mappings'] : ['device', 'types', typeId, 'mappings'];
+      return this.callApi('GET', 200, true, base);
+    }
+  }, {
+    key: "getActiveDeviceTypePropertyMappings",
+    value: function getActiveDeviceTypePropertyMappings(typeId) {
+      return this.callApi('GET', 200, true, ['device', 'types', typeId, 'mappings']);
+    }
+  }, {
+    key: "getDeviceTypeLogicalInterfacePropertyMappings",
+    value: function getDeviceTypeLogicalInterfacePropertyMappings(typeId, logicalInterfaceId) {
+      var base = this.draftMode ? ['draft', 'device', 'types', typeId, 'mappings', logicalInterfaceId] : ['device', 'types', typeId, 'mappings', logicalInterfaceId];
+      return this.callApi('GET', 200, true, base);
+    }
+  }, {
+    key: "getActiveDeviceTypeLogicalInterfacePropertyMappings",
+    value: function getActiveDeviceTypeLogicalInterfacePropertyMappings(typeId, logicalInterfaceId) {
+      return this.callApi('GET', 200, true, ['device', 'types', typeId, 'mappings', logicalInterfaceId]);
+    }
+  }, {
+    key: "updateDeviceTypeLogicalInterfacePropertyMappings",
+    value: function updateDeviceTypeLogicalInterfacePropertyMappings(typeId, logicalInterfaceId, mappings, notificationStrategy) {
+      var body = null,
+          base = null;
+
+      if (this.draftMode) {
+        body = {
+          "logicalInterfaceId": logicalInterfaceId,
+          "propertyMappings": mappings,
+          "notificationStrategy": "never"
+        };
+
+        if (notificationStrategy) {
+          body.notificationStrategy = notificationStrategy;
+        }
+
+        base = ['draft', 'device', 'types', typeId, 'mappings', logicalInterfaceId];
+      } else {
+        body = {
+          "applicationInterfaceId": logicalInterfaceId,
+          "propertyMappings": mappings
+        };
+        base = ['device', 'types', typeId, 'mappings', logicalInterfaceId];
+      }
+
+      return this.callApi('PUT', 200, false, base, body);
+    }
+  }, {
+    key: "deleteDeviceTypeLogicalInterfacePropertyMappings",
+    value: function deleteDeviceTypeLogicalInterfacePropertyMappings(typeId, logicalInterfaceId) {
+      var base = this.draftMode ? ['draft', 'device', 'types', typeId, 'mappings', logicalInterfaceId] : ['device', 'types', typeId, 'mappings', logicalInterfaceId];
+      return this.callApi('DELETE', 204, false, base);
+    }
+  }, {
+    key: "deleteDeviceTypeLogicalInterfaceAssociation",
+    value: function deleteDeviceTypeLogicalInterfaceAssociation(typeId, logicalInterfaceId) {
+      var base = this.draftMode ? ['draft', 'device', 'types', typeId, 'logicalinterfaces', logicalInterfaceId] : ['device', 'types', typeId, 'applicationinterfaces', logicalInterfaceId];
+      return this.callApi('DELETE', 204, false, base);
+    } // Device Type patch operation on draft version
+    // Acceptable operation id - validate-configuration, activate-configuration, list-differences 
+
+  }, {
+    key: "patchOperationDeviceType",
+    value: function patchOperationDeviceType(typeId, operationId) {
+      if (!operationId) {
+        return invalidOperation("PATCH operation is not allowed. Operation id is expected");
+      }
+
+      var body = {
+        "operation": operationId
+      };
+      var base = this.draftMode ? ['draft', 'device', 'types', typeId] : ['device', 'types', typeId];
+
+      if (this.draftMode) {
+        switch (operationId) {
+          case 'validate-configuration':
+            return this.callApi('PATCH', 200, true, base, body);
+            break;
+
+          case 'activate-configuration':
+            return this.callApi('PATCH', 202, true, base, body);
+            break;
+
+          case 'deactivate-configuration':
+            return this.callApi('PATCH', 202, true, base, body);
+            break;
+
+          case 'list-differences':
+            return this.callApi('PATCH', 200, true, base, body);
+            break;
+
+          default:
+            return this.invalidOperation("PATCH operation is not allowed. Invalid operation id");
+        }
+      } else {
+        switch (operationId) {
+          case 'validate-configuration':
+            return this.callApi('PATCH', 200, true, base, body);
+            break;
+
+          case 'deploy-configuration':
+            return this.callApi('PATCH', 202, true, base, body);
+            break;
+
+          case 'remove-deployed-configuration':
+            return this.callApi('PATCH', 202, true, base, body);
+            break;
+
+          case 'list-differences':
+            return this.invalidOperation("PATCH operation 'list-differences' is not allowed");
+            break;
+
+          default:
+            return this.invalidOperation("PATCH operation is not allowed. Invalid operation id");
+        }
+      }
+    } // Device Type patch operation on active version
+    // Acceptable operation id - deactivate-configuration 
+
+  }, {
+    key: "patchOperationActiveDeviceType",
+    value: function patchOperationActiveDeviceType(typeId, operationId) {
+      var body = {
+        "operation": operationId
+      };
+
+      if (this.draftMode) {
+        return this.callApi('PATCH', 202, true, ['device', 'types', typeId], body);
+      } else {
+        return this.invalidOperation("PATCH operation 'deactivate-configuration' is not allowed");
+      }
+    }
+  }, {
+    key: "getDeviceTypeDeployedConfiguration",
+    value: function getDeviceTypeDeployedConfiguration(typeId) {
+      if (this.draftMode) {
+        return this.invalidOperation("GET deployed configuration is not allowed");
+      } else {
+        return this.callApi('GET', 200, true, ['device', 'types', typeId, 'deployedconfiguration']);
+      }
+    }
+  }, {
+    key: "getDeviceState",
+    value: function getDeviceState(typeId, deviceId, logicalInterfaceId) {
+      return this.callApi('GET', 200, true, ['device', 'types', typeId, 'devices', deviceId, 'state', logicalInterfaceId]);
+    }
+  }, {
+    key: "createSchemaAndEventType",
+    value: function createSchemaAndEventType(schemaContents, schemaFileName, eventTypeName, eventDescription) {
+      var _this = this;
+
+      var body = {
+        'schemaFile': schemaContents,
+        'schemaType': 'json-schema',
+        'name': schemaFileName
+      };
+      var createSchema = new Promise(function (resolve, reject) {
+        var base = _this.draftMode ? ["draft", "schemas"] : ["schemas"];
+
+        _this.callFormDataApi('POST', 201, true, base, body, null).then(function (result) {
+          resolve(result);
+        }, function (error) {
+          reject(error);
+        });
+      });
+      return createSchema.then(function (value) {
+        var schemaId = value["id"];
+        return _this.createEventType(eventTypeName, eventDescription, schemaId);
+      });
+    }
+  }, {
+    key: "createSchemaAndLogicalInterface",
+    value: function createSchemaAndLogicalInterface(schemaContents, schemaFileName, appInterfaceName, appInterfaceDescription, appInterfaceAlias) {
+      var _this2 = this;
+
+      var body = {
+        'schemaFile': schemaContents,
+        'schemaType': 'json-schema',
+        'name': schemaFileName
+      };
+      var createSchema = new Promise(function (resolve, reject) {
+        var base = _this2.draftMode ? ["draft", "schemas"] : ["schemas"];
+
+        _this2.callFormDataApi('POST', 201, true, base, body, null).then(function (result) {
+          resolve(result);
+        }, function (error) {
+          reject(error);
+        });
+      });
+      return createSchema.then(function (value) {
+        var schemaId = value.id;
+        return _this2.createLogicalInterface(appInterfaceName, appInterfaceDescription, schemaId, appInterfaceAlias);
+      });
+    }
+  }, {
+    key: "createPhysicalInterfaceWithEventMapping",
+    value: function createPhysicalInterfaceWithEventMapping(physicalInterfaceName, description, eventId, eventTypeId) {
+      var _this3 = this;
+
+      var createPhysicalInterface = new Promise(function (resolve, reject) {
+        _this3.createPhysicalInterface(physicalInterfaceName, description).then(function (result) {
+          resolve(result);
+        }, function (error) {
+          reject(error);
+        });
+      });
+      return createPhysicalInterface.then(function (value) {
+        var physicalInterface = value;
+        var PhysicalInterfaceEventMapping = new Promise(function (resolve, reject) {
+          _this3.createPhysicalInterfaceEventMapping(physicalInterface.id, eventId, eventTypeId).then(function (result) {
+            resolve([physicalInterface, result]);
+          }, function (error) {
+            reject(error);
+          });
+        });
+        return PhysicalInterfaceEventMapping.then(function (result) {
+          return result;
+        });
+      });
+    }
+  }, {
+    key: "createDeviceTypeLogicalInterfaceEventMapping",
+    value: function createDeviceTypeLogicalInterfaceEventMapping(deviceTypeName, description, logicalInterfaceId, eventMapping, notificationStrategy) {
+      var _this4 = this;
+
+      var createDeviceType = new Promise(function (resolve, reject) {
+        _this4.createDeviceType(deviceTypeName, description).then(function (result) {
+          resolve(result);
+        }, function (error) {
+          reject(error);
+        });
+      });
+      return createDeviceType.then(function (result) {
+        var deviceObject = result;
+        var deviceTypeLogicalInterface = null;
+        var deviceTypeLogicalInterface = new Promise(function (resolve, reject) {
+          _this4.createDeviceTypeLogicalInterfaceAssociation(deviceObject.id, logicalInterfaceId).then(function (result) {
+            resolve(result);
+          }, function (error) {
+            reject(error);
+          });
+        });
+        return deviceTypeLogicalInterface.then(function (result) {
+          deviceTypeLogicalInterface = result;
+          var deviceTypeLogicalInterfacePropertyMappings = new Promise(function (resolve, reject) {
+            var notificationstrategy = "never";
+
+            if (notificationStrategy) {
+              notificationstrategy = notificationStrategy;
+            }
+
+            _this4.createDeviceTypeLogicalInterfacePropertyMappings(deviceObject.id, logicalInterfaceId, eventMapping, notificationstrategy).then(function (result) {
+              var arr = [deviceObject, deviceTypeLogicalInterface, result];
+              resolve(arr);
+            }, function (error) {
+              reject(error);
+            });
+          });
+          return deviceTypeLogicalInterfacePropertyMappings.then(function (result) {
+            return result;
+          });
+        });
+      });
+    }
+  }]);
+
+  return StateClient;
+}();
+
+exports["default"] = StateClient;
+;