@blues-inc/notehub-js 2.2.1-beta.3 → 2.3.0

package/dist/api/DeviceApi.js

@@ -6,26 +6,26 @@ Object.defineProperty(exports, "__esModule", {
 exports["default"] = void 0;
 var _ApiClient = _interopRequireDefault(require("../ApiClient"));
 var _Body = _interopRequireDefault(require("../model/Body"));
-var _DeleteNotefilesRequest = _interopRequireDefault(require("../model/DeleteNotefilesRequest"));
 var _Device = _interopRequireDefault(require("../model/Device"));
 var _EnvTreeJsonNode = _interopRequireDefault(require("../model/EnvTreeJsonNode"));
 var _EnvironmentVariables = _interopRequireDefault(require("../model/EnvironmentVariables"));
 var _Error = _interopRequireDefault(require("../model/Error"));
-var _GetDbNote200Response = _interopRequireDefault(require("../model/GetDbNote200Response"));
 var _GetDeviceEnvironmentVariablesByPin200Response = _interopRequireDefault(require("../model/GetDeviceEnvironmentVariablesByPin200Response"));
 var _GetDeviceHealthLog200Response = _interopRequireDefault(require("../model/GetDeviceHealthLog200Response"));
-var _GetDeviceLatestEvents200Response = _interopRequireDefault(require("../model/GetDeviceLatestEvents200Response"));
+var _GetDeviceLatest200Response = _interopRequireDefault(require("../model/GetDeviceLatest200Response"));
 var _GetDevicePlans200Response = _interopRequireDefault(require("../model/GetDevicePlans200Response"));
 var _GetDevicePublicKey200Response = _interopRequireDefault(require("../model/GetDevicePublicKey200Response"));
-var _GetDevicePublicKeys200Response = _interopRequireDefault(require("../model/GetDevicePublicKeys200Response"));
 var _GetDeviceSessions200Response = _interopRequireDefault(require("../model/GetDeviceSessions200Response"));
-var _GetDevices200Response = _interopRequireDefault(require("../model/GetDevices200Response"));
-var _GetNotefile200Response = _interopRequireDefault(require("../model/GetNotefile200Response"));
-var _ListPendingNotefiles200Response = _interopRequireDefault(require("../model/ListPendingNotefiles200Response"));
+var _GetProjectDevicePublicKeys200Response = _interopRequireDefault(require("../model/GetProjectDevicePublicKeys200Response"));
+var _GetProjectDevices200Response = _interopRequireDefault(require("../model/GetProjectDevices200Response"));
+var _HandleNoteChanges200Response = _interopRequireDefault(require("../model/HandleNoteChanges200Response"));
+var _HandleNoteGet200Response = _interopRequireDefault(require("../model/HandleNoteGet200Response"));
+var _HandleNoteSignal200Response = _interopRequireDefault(require("../model/HandleNoteSignal200Response"));
+var _HandleNotefileChanges200Response = _interopRequireDefault(require("../model/HandleNotefileChanges200Response"));
+var _HandleNotefileChangesPending200Response = _interopRequireDefault(require("../model/HandleNotefileChangesPending200Response"));
+var _HandleNotefileDeleteRequest = _interopRequireDefault(require("../model/HandleNotefileDeleteRequest"));
 var _Note = _interopRequireDefault(require("../model/Note"));
-var _Notefile = _interopRequireDefault(require("../model/Notefile"));
-var _ProvisionDeviceRequest = _interopRequireDefault(require("../model/ProvisionDeviceRequest"));
-var _SignalDevice200Response = _interopRequireDefault(require("../model/SignalDevice200Response"));
+var _PostProvisionProjectDeviceRequest = _interopRequireDefault(require("../model/PostProvisionProjectDeviceRequest"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
@@ -34,7 +34,7 @@ function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r),
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /**
  * Notehub API
- * The OpenAPI definition for the Notehub.io API. 
+ * The OpenAPI definition for the Notehub.io API.
  *
  * The version of the OpenAPI document: 1.2.0
  * Contact: engineering@blues.io
@@ -45,1716 +45,1704 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
  *
  */
 /**
-* Device service.
-* @module api/DeviceApi
-* @version 2.2.1-beta.3
-*/
+ * Device service.
+ * @module api/DeviceApi
+ * @version 2.3.0
+ */
 var DeviceApi = exports["default"] = /*#__PURE__*/function () {
   /**
-  * Constructs a new DeviceApi. 
-  * @alias module:api/DeviceApi
-  * @class
-  * @param {module:ApiClient} [apiClient] Optional API client implementation to use,
-  * default to {@link module:ApiClient#instance} if unspecified.
-  */
+   * Constructs a new DeviceApi.
+   * @alias module:api/DeviceApi
+   * @class
+   * @param {module:ApiClient} [apiClient] Optional API client implementation to use,
+   * default to {@link module:ApiClient#instance} if unspecified.
+   */
   function DeviceApi(apiClient) {
     _classCallCheck(this, DeviceApi);
     this.apiClient = apiClient || _ApiClient["default"].instance;
   }
 
   /**
-   * Add a Note to a .db notefile
-   * @param {String} projectOrProductUID 
-   * @param {String} deviceUID 
-   * @param {String} notefileID 
-   * @param {String} noteID 
-   * @param {module:model/Note} note Body or payload of note to be added to the device
-   * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
+   * Delete environment variable of a device
+   * @param {String} projectOrProductUID
+   * @param {String} deviceUID
+   * @param {String} key The environment variable key to delete.
+   * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EnvironmentVariables} and HTTP response
    */
   return _createClass(DeviceApi, [{
-    key: "addDbNoteWithHttpInfo",
-    value: function addDbNoteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, note) {
-      var postBody = note;
+    key: "deleteDeviceEnvironmentVariableWithHttpInfo",
+    value: function deleteDeviceEnvironmentVariableWithHttpInfo(projectOrProductUID, deviceUID, key) {
+      var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling addDbNote");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling deleteDeviceEnvironmentVariable");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling addDbNote");
-      }
-      // verify the required parameter 'notefileID' is set
-      if (notefileID === undefined || notefileID === null) {
-        throw new _Error["default"]("Missing the required parameter 'notefileID' when calling addDbNote");
-      }
-      // verify the required parameter 'noteID' is set
-      if (noteID === undefined || noteID === null) {
-        throw new _Error["default"]("Missing the required parameter 'noteID' when calling addDbNote");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling deleteDeviceEnvironmentVariable");
       }
-      // verify the required parameter 'note' is set
-      if (note === undefined || note === null) {
-        throw new _Error["default"]("Missing the required parameter 'note' when calling addDbNote");
+      // verify the required parameter 'key' is set
+      if (key === undefined || key === null) {
+        throw new _Error["default"]("Missing the required parameter 'key' when calling deleteDeviceEnvironmentVariable");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID,
-        'notefileID': notefileID,
-        'noteID': noteID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID,
+        key: key
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
-      var contentTypes = ['application/json'];
-      var accepts = ['application/json'];
-      var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/notes/{notefileID}/{noteID}', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var authNames = ["personalAccessToken"];
+      var contentTypes = [];
+      var accepts = ["application/json"];
+      var returnType = _EnvironmentVariables["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/environment_variables/{key}", "DELETE", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Add a Note to a .db notefile
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} notefileID 
-     * @param {String} noteID 
-     * @param {module:model/Note} note Body or payload of note to be added to the device
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
+     * Delete environment variable of a device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} key The environment variable key to delete.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EnvironmentVariables}
      */
   }, {
-    key: "addDbNote",
-    value: function addDbNote(projectOrProductUID, deviceUID, notefileID, noteID, note) {
-      return this.addDbNoteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, note).then(function (response_and_data) {
+    key: "deleteDeviceEnvironmentVariable",
+    value: function deleteDeviceEnvironmentVariable(projectOrProductUID, deviceUID, key) {
+      return this.deleteDeviceEnvironmentVariableWithHttpInfo(projectOrProductUID, deviceUID, key).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Add environment variables of a device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {module:model/EnvironmentVariables} environmentVariables Environment variables to be added to the device
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EnvironmentVariables} and HTTP response
+     * Delete Device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {Boolean} purge
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
-    key: "addDeviceEnvironmentVariablesWithHttpInfo",
-    value: function addDeviceEnvironmentVariablesWithHttpInfo(projectOrProductUID, deviceUID, environmentVariables) {
-      var postBody = environmentVariables;
+    key: "deleteProjectDeviceWithHttpInfo",
+    value: function deleteProjectDeviceWithHttpInfo(projectOrProductUID, deviceUID, purge) {
+      var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling addDeviceEnvironmentVariables");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling deleteProjectDevice");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling addDeviceEnvironmentVariables");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling deleteProjectDevice");
       }
-      // verify the required parameter 'environmentVariables' is set
-      if (environmentVariables === undefined || environmentVariables === null) {
-        throw new _Error["default"]("Missing the required parameter 'environmentVariables' when calling addDeviceEnvironmentVariables");
+      // verify the required parameter 'purge' is set
+      if (purge === undefined || purge === null) {
+        throw new _Error["default"]("Missing the required parameter 'purge' when calling deleteProjectDevice");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
+      };
+      var queryParams = {
+        purge: purge
       };
-      var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
-      var contentTypes = ['application/json'];
-      var accepts = ['application/json'];
-      var returnType = _EnvironmentVariables["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/environment_variables', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var authNames = ["personalAccessToken"];
+      var contentTypes = [];
+      var accepts = ["application/json"];
+      var returnType = null;
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}", "DELETE", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Add environment variables of a device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {module:model/EnvironmentVariables} environmentVariables Environment variables to be added to the device
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EnvironmentVariables}
+     * Delete Device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {Boolean} purge
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
-    key: "addDeviceEnvironmentVariables",
-    value: function addDeviceEnvironmentVariables(projectOrProductUID, deviceUID, environmentVariables) {
-      return this.addDeviceEnvironmentVariablesWithHttpInfo(projectOrProductUID, deviceUID, environmentVariables).then(function (response_and_data) {
+    key: "deleteProjectDevice",
+    value: function deleteProjectDevice(projectOrProductUID, deviceUID, purge) {
+      return this.deleteProjectDeviceWithHttpInfo(projectOrProductUID, deviceUID, purge).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Add environment variables of a device with device pin authorization
-     * @param {String} productUID 
-     * @param {String} deviceUID 
-     * @param {module:model/EnvironmentVariables} environmentVariables Environment variables to be added to the device
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EnvironmentVariables} and HTTP response
+     * Disable Device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
-    key: "addDeviceEnvironmentVariablesByPinWithHttpInfo",
-    value: function addDeviceEnvironmentVariablesByPinWithHttpInfo(productUID, deviceUID, environmentVariables) {
-      var postBody = environmentVariables;
-      // verify the required parameter 'productUID' is set
-      if (productUID === undefined || productUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'productUID' when calling addDeviceEnvironmentVariablesByPin");
+    key: "disableDeviceWithHttpInfo",
+    value: function disableDeviceWithHttpInfo(projectOrProductUID, deviceUID) {
+      var postBody = null;
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling disableDevice");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling addDeviceEnvironmentVariablesByPin");
-      }
-      // verify the required parameter 'environmentVariables' is set
-      if (environmentVariables === undefined || environmentVariables === null) {
-        throw new _Error["default"]("Missing the required parameter 'environmentVariables' when calling addDeviceEnvironmentVariablesByPin");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling disableDevice");
       }
       var pathParams = {
-        'productUID': productUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['pin'];
-      var contentTypes = ['application/json'];
-      var accepts = ['application/json'];
-      var returnType = _EnvironmentVariables["default"];
-      return this.apiClient.callApi('/v1/products/{productUID}/devices/{deviceUID}/environment_variables_with_pin', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var authNames = ["personalAccessToken"];
+      var contentTypes = [];
+      var accepts = ["application/json"];
+      var returnType = null;
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/disable", "POST", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Add environment variables of a device with device pin authorization
-     * @param {String} productUID 
-     * @param {String} deviceUID 
-     * @param {module:model/EnvironmentVariables} environmentVariables Environment variables to be added to the device
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EnvironmentVariables}
+     * Disable Device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
-    key: "addDeviceEnvironmentVariablesByPin",
-    value: function addDeviceEnvironmentVariablesByPin(productUID, deviceUID, environmentVariables) {
-      return this.addDeviceEnvironmentVariablesByPinWithHttpInfo(productUID, deviceUID, environmentVariables).then(function (response_and_data) {
+    key: "disableDevice",
+    value: function disableDevice(projectOrProductUID, deviceUID) {
+      return this.disableDeviceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Adds a Note to a Notefile, creating the Notefile if it doesn't yet exist.
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} notefileID 
-     * @param {module:model/Note} note Body or payload of note to be added to the device
+     * Disable Connectivity Assurance
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
-    key: "addQiNoteWithHttpInfo",
-    value: function addQiNoteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, note) {
-      var postBody = note;
+    key: "disableDeviceConnectivityAssuranceWithHttpInfo",
+    value: function disableDeviceConnectivityAssuranceWithHttpInfo(projectOrProductUID, deviceUID) {
+      var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling addQiNote");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling disableDeviceConnectivityAssurance");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling addQiNote");
-      }
-      // verify the required parameter 'notefileID' is set
-      if (notefileID === undefined || notefileID === null) {
-        throw new _Error["default"]("Missing the required parameter 'notefileID' when calling addQiNote");
-      }
-      // verify the required parameter 'note' is set
-      if (note === undefined || note === null) {
-        throw new _Error["default"]("Missing the required parameter 'note' when calling addQiNote");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling disableDeviceConnectivityAssurance");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID,
-        'notefileID': notefileID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
-      var contentTypes = ['application/json'];
-      var accepts = ['application/json'];
+      var authNames = ["personalAccessToken"];
+      var contentTypes = [];
+      var accepts = ["application/json"];
       var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/notes/{notefileID}', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/disable-connectivity-assurance", "POST", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Adds a Note to a Notefile, creating the Notefile if it doesn't yet exist.
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} notefileID 
-     * @param {module:model/Note} note Body or payload of note to be added to the device
+     * Disable Connectivity Assurance
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
-    key: "addQiNote",
-    value: function addQiNote(projectOrProductUID, deviceUID, notefileID, note) {
-      return this.addQiNoteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, note).then(function (response_and_data) {
+    key: "disableDeviceConnectivityAssurance",
+    value: function disableDeviceConnectivityAssurance(projectOrProductUID, deviceUID) {
+      return this.disableDeviceConnectivityAssuranceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Delete a note from a .db notefile
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} notefileID 
-     * @param {String} noteID 
+     * Enable Device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
-    key: "deleteDbNoteWithHttpInfo",
-    value: function deleteDbNoteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID) {
+    key: "enableDeviceWithHttpInfo",
+    value: function enableDeviceWithHttpInfo(projectOrProductUID, deviceUID) {
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling deleteDbNote");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling enableDevice");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling deleteDbNote");
-      }
-      // verify the required parameter 'notefileID' is set
-      if (notefileID === undefined || notefileID === null) {
-        throw new _Error["default"]("Missing the required parameter 'notefileID' when calling deleteDbNote");
-      }
-      // verify the required parameter 'noteID' is set
-      if (noteID === undefined || noteID === null) {
-        throw new _Error["default"]("Missing the required parameter 'noteID' when calling deleteDbNote");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling enableDevice");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID,
-        'notefileID': notefileID,
-        'noteID': noteID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
+      var accepts = ["application/json"];
       var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/notes/{notefileID}/{noteID}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/enable", "POST", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Delete a note from a .db notefile
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} notefileID 
-     * @param {String} noteID 
+     * Enable Device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
-    key: "deleteDbNote",
-    value: function deleteDbNote(projectOrProductUID, deviceUID, notefileID, noteID) {
-      return this.deleteDbNoteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID).then(function (response_and_data) {
+    key: "enableDevice",
+    value: function enableDevice(projectOrProductUID, deviceUID) {
+      return this.enableDeviceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Delete Device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {Boolean} purge 
+     * Enable Connectivity Assurance
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
-    key: "deleteDeviceWithHttpInfo",
-    value: function deleteDeviceWithHttpInfo(projectOrProductUID, deviceUID, purge) {
+    key: "enableDeviceConnectivityAssuranceWithHttpInfo",
+    value: function enableDeviceConnectivityAssuranceWithHttpInfo(projectOrProductUID, deviceUID) {
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling deleteDevice");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling enableDeviceConnectivityAssurance");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling deleteDevice");
-      }
-      // verify the required parameter 'purge' is set
-      if (purge === undefined || purge === null) {
-        throw new _Error["default"]("Missing the required parameter 'purge' when calling deleteDevice");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling enableDeviceConnectivityAssurance");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
-      };
-      var queryParams = {
-        'purge': purge
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
+      var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
+      var accepts = ["application/json"];
       var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/enable-connectivity-assurance", "POST", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Delete Device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {Boolean} purge 
+     * Enable Connectivity Assurance
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
-    key: "deleteDevice",
-    value: function deleteDevice(projectOrProductUID, deviceUID, purge) {
-      return this.deleteDeviceWithHttpInfo(projectOrProductUID, deviceUID, purge).then(function (response_and_data) {
+    key: "enableDeviceConnectivityAssurance",
+    value: function enableDeviceConnectivityAssurance(projectOrProductUID, deviceUID) {
+      return this.enableDeviceConnectivityAssuranceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Delete environment variable of a device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} key The environment variable key to delete.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EnvironmentVariables} and HTTP response
+     * Get Device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Device} and HTTP response
      */
   }, {
-    key: "deleteDeviceEnvironmentVariableWithHttpInfo",
-    value: function deleteDeviceEnvironmentVariableWithHttpInfo(projectOrProductUID, deviceUID, key) {
+    key: "getDeviceWithHttpInfo",
+    value: function getDeviceWithHttpInfo(projectOrProductUID, deviceUID) {
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling deleteDeviceEnvironmentVariable");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDevice");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling deleteDeviceEnvironmentVariable");
-      }
-      // verify the required parameter 'key' is set
-      if (key === undefined || key === null) {
-        throw new _Error["default"]("Missing the required parameter 'key' when calling deleteDeviceEnvironmentVariable");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDevice");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID,
-        'key': key
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _EnvironmentVariables["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/environment_variables/{key}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _Device["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Delete environment variable of a device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} key The environment variable key to delete.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EnvironmentVariables}
+     * Get Device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Device}
      */
   }, {
-    key: "deleteDeviceEnvironmentVariable",
-    value: function deleteDeviceEnvironmentVariable(projectOrProductUID, deviceUID, key) {
-      return this.deleteDeviceEnvironmentVariableWithHttpInfo(projectOrProductUID, deviceUID, key).then(function (response_and_data) {
+    key: "getDevice",
+    value: function getDevice(projectOrProductUID, deviceUID) {
+      return this.getDeviceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Deletes Notefiles and the Notes they contain.
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {module:model/DeleteNotefilesRequest} deleteNotefilesRequest 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
+     * Get environment variable hierarchy for a device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EnvTreeJsonNode} and HTTP response
      */
   }, {
-    key: "deleteNotefilesWithHttpInfo",
-    value: function deleteNotefilesWithHttpInfo(projectOrProductUID, deviceUID, deleteNotefilesRequest) {
-      var postBody = deleteNotefilesRequest;
+    key: "getDeviceEnvironmentHierarchyWithHttpInfo",
+    value: function getDeviceEnvironmentHierarchyWithHttpInfo(projectOrProductUID, deviceUID) {
+      var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling deleteNotefiles");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceEnvironmentHierarchy");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling deleteNotefiles");
-      }
-      // verify the required parameter 'deleteNotefilesRequest' is set
-      if (deleteNotefilesRequest === undefined || deleteNotefilesRequest === null) {
-        throw new _Error["default"]("Missing the required parameter 'deleteNotefilesRequest' when calling deleteNotefiles");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceEnvironmentHierarchy");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
-      var contentTypes = ['application/json'];
-      var accepts = ['application/json'];
-      var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/files', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var authNames = ["personalAccessToken"];
+      var contentTypes = [];
+      var accepts = ["application/json"];
+      var returnType = _EnvTreeJsonNode["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/environment_hierarchy", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Deletes Notefiles and the Notes they contain.
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {module:model/DeleteNotefilesRequest} deleteNotefilesRequest 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
+     * Get environment variable hierarchy for a device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EnvTreeJsonNode}
      */
   }, {
-    key: "deleteNotefiles",
-    value: function deleteNotefiles(projectOrProductUID, deviceUID, deleteNotefilesRequest) {
-      return this.deleteNotefilesWithHttpInfo(projectOrProductUID, deviceUID, deleteNotefilesRequest).then(function (response_and_data) {
+    key: "getDeviceEnvironmentHierarchy",
+    value: function getDeviceEnvironmentHierarchy(projectOrProductUID, deviceUID) {
+      return this.getDeviceEnvironmentHierarchyWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Disable Device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
+     * Get environment variables of a device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDeviceEnvironmentVariablesByPin200Response} and HTTP response
      */
   }, {
-    key: "disableDeviceWithHttpInfo",
-    value: function disableDeviceWithHttpInfo(projectOrProductUID, deviceUID) {
+    key: "getDeviceEnvironmentVariablesWithHttpInfo",
+    value: function getDeviceEnvironmentVariablesWithHttpInfo(projectOrProductUID, deviceUID) {
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling disableDevice");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceEnvironmentVariables");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling disableDevice");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceEnvironmentVariables");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/disable', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _GetDeviceEnvironmentVariablesByPin200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/environment_variables", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Disable Device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
+     * Get environment variables of a device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceEnvironmentVariablesByPin200Response}
      */
   }, {
-    key: "disableDevice",
-    value: function disableDevice(projectOrProductUID, deviceUID) {
-      return this.disableDeviceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    key: "getDeviceEnvironmentVariables",
+    value: function getDeviceEnvironmentVariables(projectOrProductUID, deviceUID) {
+      return this.getDeviceEnvironmentVariablesWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Disable Connectivity Assurance
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
+     * Get environment variables of a device with device pin authorization
+     * @param {String} productUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDeviceEnvironmentVariablesByPin200Response} and HTTP response
      */
   }, {
-    key: "disableDeviceConnectivityAssuranceWithHttpInfo",
-    value: function disableDeviceConnectivityAssuranceWithHttpInfo(projectOrProductUID, deviceUID) {
+    key: "getDeviceEnvironmentVariablesByPinWithHttpInfo",
+    value: function getDeviceEnvironmentVariablesByPinWithHttpInfo(productUID, deviceUID) {
       var postBody = null;
-      // verify the required parameter 'projectOrProductUID' is set
-      if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling disableDeviceConnectivityAssurance");
+      // verify the required parameter 'productUID' is set
+      if (productUID === undefined || productUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'productUID' when calling getDeviceEnvironmentVariablesByPin");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling disableDeviceConnectivityAssurance");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceEnvironmentVariablesByPin");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        productUID: productUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["pin"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/disable-connectivity-assurance', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _GetDeviceEnvironmentVariablesByPin200Response["default"];
+      return this.apiClient.callApi("/v1/products/{productUID}/devices/{deviceUID}/environment_variables_with_pin", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Disable Connectivity Assurance
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
+     * Get environment variables of a device with device pin authorization
+     * @param {String} productUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceEnvironmentVariablesByPin200Response}
      */
   }, {
-    key: "disableDeviceConnectivityAssurance",
-    value: function disableDeviceConnectivityAssurance(projectOrProductUID, deviceUID) {
-      return this.disableDeviceConnectivityAssuranceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    key: "getDeviceEnvironmentVariablesByPin",
+    value: function getDeviceEnvironmentVariablesByPin(productUID, deviceUID) {
+      return this.getDeviceEnvironmentVariablesByPinWithHttpInfo(productUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Enable Device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
+     * Get Device Health Log
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.startDate Start date for filtering results, specified as a Unix timestamp
+     * @param {Number} opts.endDate End date for filtering results, specified as a Unix timestamp
+     * @param {Array.<module:model/String>} opts.logType Return only specified log types
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDeviceHealthLog200Response} and HTTP response
      */
   }, {
-    key: "enableDeviceWithHttpInfo",
-    value: function enableDeviceWithHttpInfo(projectOrProductUID, deviceUID) {
+    key: "getDeviceHealthLogWithHttpInfo",
+    value: function getDeviceHealthLogWithHttpInfo(projectOrProductUID, deviceUID, opts) {
+      opts = opts || {};
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling enableDevice");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceHealthLog");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling enableDevice");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceHealthLog");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
+      };
+      var queryParams = {
+        startDate: opts["startDate"],
+        endDate: opts["endDate"],
+        log_type: this.apiClient.buildCollectionParam(opts["logType"], "multi")
       };
-      var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/enable', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _GetDeviceHealthLog200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/health-log", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Enable Device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
+     * Get Device Health Log
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.startDate Start date for filtering results, specified as a Unix timestamp
+     * @param {Number} opts.endDate End date for filtering results, specified as a Unix timestamp
+     * @param {Array.<module:model/String>} opts.logType Return only specified log types
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceHealthLog200Response}
      */
   }, {
-    key: "enableDevice",
-    value: function enableDevice(projectOrProductUID, deviceUID) {
-      return this.enableDeviceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    key: "getDeviceHealthLog",
+    value: function getDeviceHealthLog(projectOrProductUID, deviceUID, opts) {
+      return this.getDeviceHealthLogWithHttpInfo(projectOrProductUID, deviceUID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Enable Connectivity Assurance
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
+     * Get Device Latest Events
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDeviceLatest200Response} and HTTP response
      */
   }, {
-    key: "enableDeviceConnectivityAssuranceWithHttpInfo",
-    value: function enableDeviceConnectivityAssuranceWithHttpInfo(projectOrProductUID, deviceUID) {
+    key: "getDeviceLatestWithHttpInfo",
+    value: function getDeviceLatestWithHttpInfo(projectOrProductUID, deviceUID) {
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling enableDeviceConnectivityAssurance");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceLatest");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling enableDeviceConnectivityAssurance");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceLatest");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/enable-connectivity-assurance', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _GetDeviceLatest200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/latest", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Enable Connectivity Assurance
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
+     * Get Device Latest Events
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceLatest200Response}
      */
   }, {
-    key: "enableDeviceConnectivityAssurance",
-    value: function enableDeviceConnectivityAssurance(projectOrProductUID, deviceUID) {
-      return this.enableDeviceConnectivityAssuranceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    key: "getDeviceLatest",
+    value: function getDeviceLatest(projectOrProductUID, deviceUID) {
+      return this.getDeviceLatestWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get a note from a .db notefile
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} notefileID 
-     * @param {String} noteID 
-     * @param {Object} opts Optional parameters
-     * @param {Boolean} opts._delete Whether to delete the note from the DB notefile
-     * @param {Boolean} opts.deleted Whether to return deleted notes
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDbNote200Response} and HTTP response
+     * Get Data Plans associated with the device, this include the primary sim, any external sim, as well as any satellite connections.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDevicePlans200Response} and HTTP response
      */
   }, {
-    key: "getDbNoteWithHttpInfo",
-    value: function getDbNoteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, opts) {
-      opts = opts || {};
+    key: "getDevicePlansWithHttpInfo",
+    value: function getDevicePlansWithHttpInfo(projectOrProductUID, deviceUID) {
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDbNote");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDevicePlans");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDbNote");
-      }
-      // verify the required parameter 'notefileID' is set
-      if (notefileID === undefined || notefileID === null) {
-        throw new _Error["default"]("Missing the required parameter 'notefileID' when calling getDbNote");
-      }
-      // verify the required parameter 'noteID' is set
-      if (noteID === undefined || noteID === null) {
-        throw new _Error["default"]("Missing the required parameter 'noteID' when calling getDbNote");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDevicePlans");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID,
-        'notefileID': notefileID,
-        'noteID': noteID
-      };
-      var queryParams = {
-        'delete': opts['_delete'],
-        'deleted': opts['deleted']
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
+      var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _GetDbNote200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/notes/{notefileID}/{noteID}', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _GetDevicePlans200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/plans", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get a note from a .db notefile
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} notefileID 
-     * @param {String} noteID 
-     * @param {Object} opts Optional parameters
-     * @param {Boolean} opts._delete Whether to delete the note from the DB notefile
-     * @param {Boolean} opts.deleted Whether to return deleted notes
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDbNote200Response}
+     * Get Data Plans associated with the device, this include the primary sim, any external sim, as well as any satellite connections.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDevicePlans200Response}
      */
   }, {
-    key: "getDbNote",
-    value: function getDbNote(projectOrProductUID, deviceUID, notefileID, noteID, opts) {
-      return this.getDbNoteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, opts).then(function (response_and_data) {
+    key: "getDevicePlans",
+    value: function getDevicePlans(projectOrProductUID, deviceUID) {
+      return this.getDevicePlansWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get Device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Device} and HTTP response
+     * Get Device Public Key
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDevicePublicKey200Response} and HTTP response
      */
   }, {
-    key: "getDeviceWithHttpInfo",
-    value: function getDeviceWithHttpInfo(projectOrProductUID, deviceUID) {
+    key: "getDevicePublicKeyWithHttpInfo",
+    value: function getDevicePublicKeyWithHttpInfo(projectOrProductUID, deviceUID) {
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDevice");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDevicePublicKey");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDevice");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDevicePublicKey");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _Device["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _GetDevicePublicKey200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/public-key", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get Device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Device}
+     * Get Device Public Key
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDevicePublicKey200Response}
      */
   }, {
-    key: "getDevice",
-    value: function getDevice(projectOrProductUID, deviceUID) {
-      return this.getDeviceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    key: "getDevicePublicKey",
+    value: function getDevicePublicKey(projectOrProductUID, deviceUID) {
+      return this.getDevicePublicKeyWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get environment variable hierarchy for a device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EnvTreeJsonNode} and HTTP response
+     * Get Device Sessions
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.pageSize  (default to 50)
+     * @param {Number} opts.pageNum  (default to 1)
+     * @param {Number} opts.startDate Start date for filtering results, specified as a Unix timestamp
+     * @param {Number} opts.endDate End date for filtering results, specified as a Unix timestamp
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDeviceSessions200Response} and HTTP response
      */
   }, {
-    key: "getDeviceEnvironmentHierarchyWithHttpInfo",
-    value: function getDeviceEnvironmentHierarchyWithHttpInfo(projectOrProductUID, deviceUID) {
+    key: "getDeviceSessionsWithHttpInfo",
+    value: function getDeviceSessionsWithHttpInfo(projectOrProductUID, deviceUID, opts) {
+      opts = opts || {};
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceEnvironmentHierarchy");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceSessions");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceEnvironmentHierarchy");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceSessions");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
+      };
+      var queryParams = {
+        pageSize: opts["pageSize"],
+        pageNum: opts["pageNum"],
+        startDate: opts["startDate"],
+        endDate: opts["endDate"]
       };
-      var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _EnvTreeJsonNode["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/environment_hierarchy', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _GetDeviceSessions200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/sessions", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get environment variable hierarchy for a device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EnvTreeJsonNode}
+     * Get Device Sessions
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.pageSize  (default to 50)
+     * @param {Number} opts.pageNum  (default to 1)
+     * @param {Number} opts.startDate Start date for filtering results, specified as a Unix timestamp
+     * @param {Number} opts.endDate End date for filtering results, specified as a Unix timestamp
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceSessions200Response}
      */
   }, {
-    key: "getDeviceEnvironmentHierarchy",
-    value: function getDeviceEnvironmentHierarchy(projectOrProductUID, deviceUID) {
-      return this.getDeviceEnvironmentHierarchyWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    key: "getDeviceSessions",
+    value: function getDeviceSessions(projectOrProductUID, deviceUID, opts) {
+      return this.getDeviceSessionsWithHttpInfo(projectOrProductUID, deviceUID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get environment variables of a device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDeviceEnvironmentVariablesByPin200Response} and HTTP response
+     * Get Device Public Keys of a Project
+     * @param {String} projectOrProductUID
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.pageSize  (default to 50)
+     * @param {Number} opts.pageNum  (default to 1)
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetProjectDevicePublicKeys200Response} and HTTP response
      */
   }, {
-    key: "getDeviceEnvironmentVariablesWithHttpInfo",
-    value: function getDeviceEnvironmentVariablesWithHttpInfo(projectOrProductUID, deviceUID) {
+    key: "getProjectDevicePublicKeysWithHttpInfo",
+    value: function getProjectDevicePublicKeysWithHttpInfo(projectOrProductUID, opts) {
+      opts = opts || {};
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceEnvironmentVariables");
-      }
-      // verify the required parameter 'deviceUID' is set
-      if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceEnvironmentVariables");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getProjectDevicePublicKeys");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID
+      };
+      var queryParams = {
+        pageSize: opts["pageSize"],
+        pageNum: opts["pageNum"]
       };
-      var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _GetDeviceEnvironmentVariablesByPin200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/environment_variables', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _GetProjectDevicePublicKeys200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/public-keys", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get environment variables of a device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceEnvironmentVariablesByPin200Response}
+     * Get Device Public Keys of a Project
+     * @param {String} projectOrProductUID
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.pageSize  (default to 50)
+     * @param {Number} opts.pageNum  (default to 1)
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetProjectDevicePublicKeys200Response}
      */
   }, {
-    key: "getDeviceEnvironmentVariables",
-    value: function getDeviceEnvironmentVariables(projectOrProductUID, deviceUID) {
-      return this.getDeviceEnvironmentVariablesWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    key: "getProjectDevicePublicKeys",
+    value: function getProjectDevicePublicKeys(projectOrProductUID, opts) {
+      return this.getProjectDevicePublicKeysWithHttpInfo(projectOrProductUID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get environment variables of a device with device pin authorization
-     * @param {String} productUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDeviceEnvironmentVariablesByPin200Response} and HTTP response
+     * Get Devices of a Project
+     * @param {String} projectOrProductUID
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.pageSize  (default to 50)
+     * @param {Number} opts.pageNum  (default to 1)
+     * @param {Array.<String>} opts.deviceUID A Device UID.
+     * @param {Array.<String>} opts.tag Tag filter
+     * @param {Array.<String>} opts.serialNumber Serial number filter
+     * @param {Array.<String>} opts.fleetUID
+     * @param {Array.<String>} opts.notecardFirmware Firmware version filter
+     * @param {Array.<String>} opts.location Location filter
+     * @param {Array.<String>} opts.hostFirmware Host firmware filter
+     * @param {Array.<String>} opts.productUID
+     * @param {Array.<String>} opts.sku SKU filter
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetProjectDevices200Response} and HTTP response
      */
   }, {
-    key: "getDeviceEnvironmentVariablesByPinWithHttpInfo",
-    value: function getDeviceEnvironmentVariablesByPinWithHttpInfo(productUID, deviceUID) {
+    key: "getProjectDevicesWithHttpInfo",
+    value: function getProjectDevicesWithHttpInfo(projectOrProductUID, opts) {
+      opts = opts || {};
       var postBody = null;
-      // verify the required parameter 'productUID' is set
-      if (productUID === undefined || productUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'productUID' when calling getDeviceEnvironmentVariablesByPin");
-      }
-      // verify the required parameter 'deviceUID' is set
-      if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceEnvironmentVariablesByPin");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getProjectDevices");
       }
       var pathParams = {
-        'productUID': productUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID
+      };
+      var queryParams = {
+        pageSize: opts["pageSize"],
+        pageNum: opts["pageNum"],
+        deviceUID: this.apiClient.buildCollectionParam(opts["deviceUID"], "multi"),
+        tag: this.apiClient.buildCollectionParam(opts["tag"], "multi"),
+        serialNumber: this.apiClient.buildCollectionParam(opts["serialNumber"], "multi"),
+        fleetUID: this.apiClient.buildCollectionParam(opts["fleetUID"], "multi"),
+        notecardFirmware: this.apiClient.buildCollectionParam(opts["notecardFirmware"], "multi"),
+        location: this.apiClient.buildCollectionParam(opts["location"], "multi"),
+        hostFirmware: this.apiClient.buildCollectionParam(opts["hostFirmware"], "multi"),
+        productUID: this.apiClient.buildCollectionParam(opts["productUID"], "multi"),
+        sku: this.apiClient.buildCollectionParam(opts["sku"], "multi")
       };
-      var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['pin'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _GetDeviceEnvironmentVariablesByPin200Response["default"];
-      return this.apiClient.callApi('/v1/products/{productUID}/devices/{deviceUID}/environment_variables_with_pin', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _GetProjectDevices200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get environment variables of a device with device pin authorization
-     * @param {String} productUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceEnvironmentVariablesByPin200Response}
+     * Get Devices of a Project
+     * @param {String} projectOrProductUID
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.pageSize  (default to 50)
+     * @param {Number} opts.pageNum  (default to 1)
+     * @param {Array.<String>} opts.deviceUID A Device UID.
+     * @param {Array.<String>} opts.tag Tag filter
+     * @param {Array.<String>} opts.serialNumber Serial number filter
+     * @param {Array.<String>} opts.fleetUID
+     * @param {Array.<String>} opts.notecardFirmware Firmware version filter
+     * @param {Array.<String>} opts.location Location filter
+     * @param {Array.<String>} opts.hostFirmware Host firmware filter
+     * @param {Array.<String>} opts.productUID
+     * @param {Array.<String>} opts.sku SKU filter
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetProjectDevices200Response}
      */
   }, {
-    key: "getDeviceEnvironmentVariablesByPin",
-    value: function getDeviceEnvironmentVariablesByPin(productUID, deviceUID) {
-      return this.getDeviceEnvironmentVariablesByPinWithHttpInfo(productUID, deviceUID).then(function (response_and_data) {
+    key: "getProjectDevices",
+    value: function getProjectDevices(projectOrProductUID, opts) {
+      return this.getProjectDevicesWithHttpInfo(projectOrProductUID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get Device Health Log
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
+     * Get Devices of a Fleet within a Project
+     * @param {String} projectOrProductUID
+     * @param {String} fleetUID
      * @param {Object} opts Optional parameters
-     * @param {Number} opts.startDate Start date for filtering results, specified as a Unix timestamp
-     * @param {Number} opts.endDate End date for filtering results, specified as a Unix timestamp
-     * @param {Array.<module:model/String>} opts.logType Return only specified log types
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDeviceHealthLog200Response} and HTTP response
+     * @param {Number} opts.pageSize  (default to 50)
+     * @param {Number} opts.pageNum  (default to 1)
+     * @param {Array.<String>} opts.deviceUID A Device UID.
+     * @param {Array.<String>} opts.tag Tag filter
+     * @param {Array.<String>} opts.serialNumber Serial number filter
+     * @param {Array.<String>} opts.notecardFirmware Firmware version filter
+     * @param {Array.<String>} opts.location Location filter
+     * @param {Array.<String>} opts.hostFirmware Host firmware filter
+     * @param {Array.<String>} opts.productUID
+     * @param {Array.<String>} opts.sku SKU filter
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetProjectDevices200Response} and HTTP response
      */
   }, {
-    key: "getDeviceHealthLogWithHttpInfo",
-    value: function getDeviceHealthLogWithHttpInfo(projectOrProductUID, deviceUID, opts) {
+    key: "getProjectFleetDevicesWithHttpInfo",
+    value: function getProjectFleetDevicesWithHttpInfo(projectOrProductUID, fleetUID, opts) {
       opts = opts || {};
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceHealthLog");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getProjectFleetDevices");
       }
-      // verify the required parameter 'deviceUID' is set
-      if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceHealthLog");
+      // verify the required parameter 'fleetUID' is set
+      if (fleetUID === undefined || fleetUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'fleetUID' when calling getProjectFleetDevices");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        fleetUID: fleetUID
       };
       var queryParams = {
-        'startDate': opts['startDate'],
-        'endDate': opts['endDate'],
-        'log_type': this.apiClient.buildCollectionParam(opts['logType'], 'multi')
+        pageSize: opts["pageSize"],
+        pageNum: opts["pageNum"],
+        deviceUID: this.apiClient.buildCollectionParam(opts["deviceUID"], "multi"),
+        tag: this.apiClient.buildCollectionParam(opts["tag"], "multi"),
+        serialNumber: this.apiClient.buildCollectionParam(opts["serialNumber"], "multi"),
+        notecardFirmware: this.apiClient.buildCollectionParam(opts["notecardFirmware"], "multi"),
+        location: this.apiClient.buildCollectionParam(opts["location"], "multi"),
+        hostFirmware: this.apiClient.buildCollectionParam(opts["hostFirmware"], "multi"),
+        productUID: this.apiClient.buildCollectionParam(opts["productUID"], "multi"),
+        sku: this.apiClient.buildCollectionParam(opts["sku"], "multi")
       };
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _GetDeviceHealthLog200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/health-log', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _GetProjectDevices200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/fleets/{fleetUID}/devices", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get Device Health Log
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
+     * Get Devices of a Fleet within a Project
+     * @param {String} projectOrProductUID
+     * @param {String} fleetUID
      * @param {Object} opts Optional parameters
-     * @param {Number} opts.startDate Start date for filtering results, specified as a Unix timestamp
-     * @param {Number} opts.endDate End date for filtering results, specified as a Unix timestamp
-     * @param {Array.<module:model/String>} opts.logType Return only specified log types
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceHealthLog200Response}
+     * @param {Number} opts.pageSize  (default to 50)
+     * @param {Number} opts.pageNum  (default to 1)
+     * @param {Array.<String>} opts.deviceUID A Device UID.
+     * @param {Array.<String>} opts.tag Tag filter
+     * @param {Array.<String>} opts.serialNumber Serial number filter
+     * @param {Array.<String>} opts.notecardFirmware Firmware version filter
+     * @param {Array.<String>} opts.location Location filter
+     * @param {Array.<String>} opts.hostFirmware Host firmware filter
+     * @param {Array.<String>} opts.productUID
+     * @param {Array.<String>} opts.sku SKU filter
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetProjectDevices200Response}
      */
   }, {
-    key: "getDeviceHealthLog",
-    value: function getDeviceHealthLog(projectOrProductUID, deviceUID, opts) {
-      return this.getDeviceHealthLogWithHttpInfo(projectOrProductUID, deviceUID, opts).then(function (response_and_data) {
+    key: "getProjectFleetDevices",
+    value: function getProjectFleetDevices(projectOrProductUID, fleetUID, opts) {
+      return this.getProjectFleetDevicesWithHttpInfo(projectOrProductUID, fleetUID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get Device Latest Events
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDeviceLatestEvents200Response} and HTTP response
+     * Adds a Note to a Notefile, creating the Notefile if it doesn't yet exist.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} notefileID
+     * @param {module:model/Note} note Body or payload of note to be added to the device
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
-    key: "getDeviceLatestEventsWithHttpInfo",
-    value: function getDeviceLatestEventsWithHttpInfo(projectOrProductUID, deviceUID) {
-      var postBody = null;
+    key: "handleNoteAddWithHttpInfo",
+    value: function handleNoteAddWithHttpInfo(projectOrProductUID, deviceUID, notefileID, note) {
+      var postBody = note;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceLatestEvents");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling handleNoteAdd");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceLatestEvents");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling handleNoteAdd");
+      }
+      // verify the required parameter 'notefileID' is set
+      if (notefileID === undefined || notefileID === null) {
+        throw new _Error["default"]("Missing the required parameter 'notefileID' when calling handleNoteAdd");
+      }
+      // verify the required parameter 'note' is set
+      if (note === undefined || note === null) {
+        throw new _Error["default"]("Missing the required parameter 'note' when calling handleNoteAdd");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID,
+        notefileID: notefileID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
-      var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _GetDeviceLatestEvents200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/latest', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var authNames = ["personalAccessToken"];
+      var contentTypes = ["application/json"];
+      var accepts = ["application/json"];
+      var returnType = null;
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/notes/{notefileID}", "POST", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get Device Latest Events
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceLatestEvents200Response}
+     * Adds a Note to a Notefile, creating the Notefile if it doesn't yet exist.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} notefileID
+     * @param {module:model/Note} note Body or payload of note to be added to the device
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
-    key: "getDeviceLatestEvents",
-    value: function getDeviceLatestEvents(projectOrProductUID, deviceUID) {
-      return this.getDeviceLatestEventsWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    key: "handleNoteAdd",
+    value: function handleNoteAdd(projectOrProductUID, deviceUID, notefileID, note) {
+      return this.handleNoteAddWithHttpInfo(projectOrProductUID, deviceUID, notefileID, note).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get Data Plans associated with the device, this include the primary sim, any external sim, as well as any satellite connections.
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDevicePlans200Response} and HTTP response
+     * Incrementally retrieve changes within a specific Notefile.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} notefileID
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.max The maximum number of Notes to return in the request.
+     * @param {Boolean} opts.deleted true to return deleted notes.
+     * @param {Boolean} opts._delete true to delete the notes returned by the request.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/HandleNoteChanges200Response} and HTTP response
      */
   }, {
-    key: "getDevicePlansWithHttpInfo",
-    value: function getDevicePlansWithHttpInfo(projectOrProductUID, deviceUID) {
+    key: "handleNoteChangesWithHttpInfo",
+    value: function handleNoteChangesWithHttpInfo(projectOrProductUID, deviceUID, notefileID, opts) {
+      opts = opts || {};
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDevicePlans");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling handleNoteChanges");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDevicePlans");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling handleNoteChanges");
+      }
+      // verify the required parameter 'notefileID' is set
+      if (notefileID === undefined || notefileID === null) {
+        throw new _Error["default"]("Missing the required parameter 'notefileID' when calling handleNoteChanges");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID,
+        notefileID: notefileID
+      };
+      var queryParams = {
+        max: opts["max"],
+        deleted: opts["deleted"],
+        "delete": opts["_delete"]
       };
-      var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _GetDevicePlans200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/plans', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _HandleNoteChanges200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/notes/{notefileID}/changes", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get Data Plans associated with the device, this include the primary sim, any external sim, as well as any satellite connections.
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDevicePlans200Response}
+     * Incrementally retrieve changes within a specific Notefile.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} notefileID
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.max The maximum number of Notes to return in the request.
+     * @param {Boolean} opts.deleted true to return deleted notes.
+     * @param {Boolean} opts._delete true to delete the notes returned by the request.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/HandleNoteChanges200Response}
      */
   }, {
-    key: "getDevicePlans",
-    value: function getDevicePlans(projectOrProductUID, deviceUID) {
-      return this.getDevicePlansWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    key: "handleNoteChanges",
+    value: function handleNoteChanges(projectOrProductUID, deviceUID, notefileID, opts) {
+      return this.handleNoteChangesWithHttpInfo(projectOrProductUID, deviceUID, notefileID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get Device Public Key
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDevicePublicKey200Response} and HTTP response
+     * Adds a Note to a Notefile, creating the Notefile if it doesn't yet exist.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} notefileID
+     * @param {String} noteID
+     * @param {module:model/Note} note Body or payload of note to be added to the device
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
-    key: "getDevicePublicKeyWithHttpInfo",
-    value: function getDevicePublicKeyWithHttpInfo(projectOrProductUID, deviceUID) {
-      var postBody = null;
+    key: "handleNoteCreateAddWithHttpInfo",
+    value: function handleNoteCreateAddWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, note) {
+      var postBody = note;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDevicePublicKey");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling handleNoteCreateAdd");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDevicePublicKey");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling handleNoteCreateAdd");
+      }
+      // verify the required parameter 'notefileID' is set
+      if (notefileID === undefined || notefileID === null) {
+        throw new _Error["default"]("Missing the required parameter 'notefileID' when calling handleNoteCreateAdd");
+      }
+      // verify the required parameter 'noteID' is set
+      if (noteID === undefined || noteID === null) {
+        throw new _Error["default"]("Missing the required parameter 'noteID' when calling handleNoteCreateAdd");
+      }
+      // verify the required parameter 'note' is set
+      if (note === undefined || note === null) {
+        throw new _Error["default"]("Missing the required parameter 'note' when calling handleNoteCreateAdd");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID,
+        notefileID: notefileID,
+        noteID: noteID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
-      var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _GetDevicePublicKey200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/public-key', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var authNames = ["personalAccessToken"];
+      var contentTypes = ["application/json"];
+      var accepts = ["application/json"];
+      var returnType = null;
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/notes/{notefileID}/{noteID}", "POST", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get Device Public Key
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDevicePublicKey200Response}
+     * Adds a Note to a Notefile, creating the Notefile if it doesn't yet exist.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} notefileID
+     * @param {String} noteID
+     * @param {module:model/Note} note Body or payload of note to be added to the device
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
-    key: "getDevicePublicKey",
-    value: function getDevicePublicKey(projectOrProductUID, deviceUID) {
-      return this.getDevicePublicKeyWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    key: "handleNoteCreateAdd",
+    value: function handleNoteCreateAdd(projectOrProductUID, deviceUID, notefileID, noteID, note) {
+      return this.handleNoteCreateAddWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, note).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get Device Public Keys of a Project
-     * @param {String} projectOrProductUID 
-     * @param {Object} opts Optional parameters
-     * @param {Number} opts.pageSize  (default to 50)
-     * @param {Number} opts.pageNum  (default to 1)
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDevicePublicKeys200Response} and HTTP response
+     * Delete a note from a DB notefile
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} notefileID
+     * @param {String} noteID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
-    key: "getDevicePublicKeysWithHttpInfo",
-    value: function getDevicePublicKeysWithHttpInfo(projectOrProductUID, opts) {
-      opts = opts || {};
+    key: "handleNoteDeleteWithHttpInfo",
+    value: function handleNoteDeleteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID) {
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDevicePublicKeys");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling handleNoteDelete");
+      }
+      // verify the required parameter 'deviceUID' is set
+      if (deviceUID === undefined || deviceUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling handleNoteDelete");
+      }
+      // verify the required parameter 'notefileID' is set
+      if (notefileID === undefined || notefileID === null) {
+        throw new _Error["default"]("Missing the required parameter 'notefileID' when calling handleNoteDelete");
+      }
+      // verify the required parameter 'noteID' is set
+      if (noteID === undefined || noteID === null) {
+        throw new _Error["default"]("Missing the required parameter 'noteID' when calling handleNoteDelete");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID
-      };
-      var queryParams = {
-        'pageSize': opts['pageSize'],
-        'pageNum': opts['pageNum']
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID,
+        notefileID: notefileID,
+        noteID: noteID
       };
+      var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _GetDevicePublicKeys200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/public-keys', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = null;
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/notes/{notefileID}/{noteID}", "DELETE", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get Device Public Keys of a Project
-     * @param {String} projectOrProductUID 
-     * @param {Object} opts Optional parameters
-     * @param {Number} opts.pageSize  (default to 50)
-     * @param {Number} opts.pageNum  (default to 1)
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDevicePublicKeys200Response}
+     * Delete a note from a DB notefile
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} notefileID
+     * @param {String} noteID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
-    key: "getDevicePublicKeys",
-    value: function getDevicePublicKeys(projectOrProductUID, opts) {
-      return this.getDevicePublicKeysWithHttpInfo(projectOrProductUID, opts).then(function (response_and_data) {
+    key: "handleNoteDelete",
+    value: function handleNoteDelete(projectOrProductUID, deviceUID, notefileID, noteID) {
+      return this.handleNoteDeleteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get Device Sessions
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
+     * Get a note from a DB notefile
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} notefileID
+     * @param {String} noteID
      * @param {Object} opts Optional parameters
-     * @param {Number} opts.pageSize  (default to 50)
-     * @param {Number} opts.pageNum  (default to 1)
-     * @param {Number} opts.startDate Start date for filtering results, specified as a Unix timestamp
-     * @param {Number} opts.endDate End date for filtering results, specified as a Unix timestamp
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDeviceSessions200Response} and HTTP response
+     * @param {Boolean} opts._delete Whether to delete the note from the DB notefile
+     * @param {Boolean} opts.deleted Whether to return deleted notes
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/HandleNoteGet200Response} and HTTP response
      */
   }, {
-    key: "getDeviceSessionsWithHttpInfo",
-    value: function getDeviceSessionsWithHttpInfo(projectOrProductUID, deviceUID, opts) {
+    key: "handleNoteGetWithHttpInfo",
+    value: function handleNoteGetWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, opts) {
       opts = opts || {};
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceSessions");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling handleNoteGet");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceSessions");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling handleNoteGet");
+      }
+      // verify the required parameter 'notefileID' is set
+      if (notefileID === undefined || notefileID === null) {
+        throw new _Error["default"]("Missing the required parameter 'notefileID' when calling handleNoteGet");
+      }
+      // verify the required parameter 'noteID' is set
+      if (noteID === undefined || noteID === null) {
+        throw new _Error["default"]("Missing the required parameter 'noteID' when calling handleNoteGet");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID,
+        notefileID: notefileID,
+        noteID: noteID
       };
       var queryParams = {
-        'pageSize': opts['pageSize'],
-        'pageNum': opts['pageNum'],
-        'startDate': opts['startDate'],
-        'endDate': opts['endDate']
+        "delete": opts["_delete"],
+        deleted: opts["deleted"]
       };
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _GetDeviceSessions200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/sessions', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _HandleNoteGet200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/notes/{notefileID}/{noteID}", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get Device Sessions
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
+     * Get a note from a DB notefile
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} notefileID
+     * @param {String} noteID
      * @param {Object} opts Optional parameters
-     * @param {Number} opts.pageSize  (default to 50)
-     * @param {Number} opts.pageNum  (default to 1)
-     * @param {Number} opts.startDate Start date for filtering results, specified as a Unix timestamp
-     * @param {Number} opts.endDate End date for filtering results, specified as a Unix timestamp
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceSessions200Response}
+     * @param {Boolean} opts._delete Whether to delete the note from the DB notefile
+     * @param {Boolean} opts.deleted Whether to return deleted notes
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/HandleNoteGet200Response}
      */
   }, {
-    key: "getDeviceSessions",
-    value: function getDeviceSessions(projectOrProductUID, deviceUID, opts) {
-      return this.getDeviceSessionsWithHttpInfo(projectOrProductUID, deviceUID, opts).then(function (response_and_data) {
+    key: "handleNoteGet",
+    value: function handleNoteGet(projectOrProductUID, deviceUID, notefileID, noteID, opts) {
+      return this.handleNoteGetWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get Devices of a Project
-     * @param {String} projectOrProductUID 
-     * @param {Object} opts Optional parameters
-     * @param {Number} opts.pageSize  (default to 50)
-     * @param {Number} opts.pageNum  (default to 1)
-     * @param {Array.<String>} opts.deviceUID A Device UID.
-     * @param {Array.<String>} opts.tag Tag filter
-     * @param {Array.<String>} opts.serialNumber Serial number filter
-     * @param {Array.<String>} opts.fleetUID 
-     * @param {Array.<String>} opts.notecardFirmware Firmware version filter
-     * @param {Array.<String>} opts.location Location filter
-     * @param {Array.<String>} opts.hostFirmware Host firmware filter
-     * @param {Array.<String>} opts.productUID 
-     * @param {Array.<String>} opts.sku SKU filter
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDevices200Response} and HTTP response
+     * Send a signal from Notehub to a Notecard.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {module:model/Body} body Body or payload of singnal to be sent to the device
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/HandleNoteSignal200Response} and HTTP response
      */
   }, {
-    key: "getDevicesWithHttpInfo",
-    value: function getDevicesWithHttpInfo(projectOrProductUID, opts) {
-      opts = opts || {};
-      var postBody = null;
+    key: "handleNoteSignalWithHttpInfo",
+    value: function handleNoteSignalWithHttpInfo(projectOrProductUID, deviceUID, body) {
+      var postBody = body;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDevices");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling handleNoteSignal");
+      }
+      // verify the required parameter 'deviceUID' is set
+      if (deviceUID === undefined || deviceUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling handleNoteSignal");
+      }
+      // verify the required parameter 'body' is set
+      if (body === undefined || body === null) {
+        throw new _Error["default"]("Missing the required parameter 'body' when calling handleNoteSignal");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID
-      };
-      var queryParams = {
-        'pageSize': opts['pageSize'],
-        'pageNum': opts['pageNum'],
-        'deviceUID': this.apiClient.buildCollectionParam(opts['deviceUID'], 'multi'),
-        'tag': this.apiClient.buildCollectionParam(opts['tag'], 'multi'),
-        'serialNumber': this.apiClient.buildCollectionParam(opts['serialNumber'], 'multi'),
-        'fleetUID': this.apiClient.buildCollectionParam(opts['fleetUID'], 'multi'),
-        'notecardFirmware': this.apiClient.buildCollectionParam(opts['notecardFirmware'], 'multi'),
-        'location': this.apiClient.buildCollectionParam(opts['location'], 'multi'),
-        'hostFirmware': this.apiClient.buildCollectionParam(opts['hostFirmware'], 'multi'),
-        'productUID': this.apiClient.buildCollectionParam(opts['productUID'], 'multi'),
-        'sku': this.apiClient.buildCollectionParam(opts['sku'], 'multi')
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
+      var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
-      var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _GetDevices200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var authNames = ["personalAccessToken"];
+      var contentTypes = ["application/json"];
+      var accepts = ["application/json"];
+      var returnType = _HandleNoteSignal200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/signal", "POST", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get Devices of a Project
-     * @param {String} projectOrProductUID 
-     * @param {Object} opts Optional parameters
-     * @param {Number} opts.pageSize  (default to 50)
-     * @param {Number} opts.pageNum  (default to 1)
-     * @param {Array.<String>} opts.deviceUID A Device UID.
-     * @param {Array.<String>} opts.tag Tag filter
-     * @param {Array.<String>} opts.serialNumber Serial number filter
-     * @param {Array.<String>} opts.fleetUID 
-     * @param {Array.<String>} opts.notecardFirmware Firmware version filter
-     * @param {Array.<String>} opts.location Location filter
-     * @param {Array.<String>} opts.hostFirmware Host firmware filter
-     * @param {Array.<String>} opts.productUID 
-     * @param {Array.<String>} opts.sku SKU filter
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDevices200Response}
+     * Send a signal from Notehub to a Notecard.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {module:model/Body} body Body or payload of singnal to be sent to the device
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/HandleNoteSignal200Response}
      */
   }, {
-    key: "getDevices",
-    value: function getDevices(projectOrProductUID, opts) {
-      return this.getDevicesWithHttpInfo(projectOrProductUID, opts).then(function (response_and_data) {
+    key: "handleNoteSignal",
+    value: function handleNoteSignal(projectOrProductUID, deviceUID, body) {
+      return this.handleNoteSignalWithHttpInfo(projectOrProductUID, deviceUID, body).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Get Devices of a Fleet within a Project
-     * @param {String} projectOrProductUID 
-     * @param {String} fleetUID 
-     * @param {Object} opts Optional parameters
-     * @param {Number} opts.pageSize  (default to 50)
-     * @param {Number} opts.pageNum  (default to 1)
-     * @param {Array.<String>} opts.deviceUID A Device UID.
-     * @param {Array.<String>} opts.tag Tag filter
-     * @param {Array.<String>} opts.serialNumber Serial number filter
-     * @param {Array.<String>} opts.notecardFirmware Firmware version filter
-     * @param {Array.<String>} opts.location Location filter
-     * @param {Array.<String>} opts.hostFirmware Host firmware filter
-     * @param {Array.<String>} opts.productUID 
-     * @param {Array.<String>} opts.sku SKU filter
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDevices200Response} and HTTP response
+     * Update a note in a DB notefile
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} notefileID
+     * @param {String} noteID
+     * @param {module:model/Note} note Body or payload of note to be added to the device
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
-    key: "getFleetDevicesWithHttpInfo",
-    value: function getFleetDevicesWithHttpInfo(projectOrProductUID, fleetUID, opts) {
-      opts = opts || {};
-      var postBody = null;
+    key: "handleNoteUpdateWithHttpInfo",
+    value: function handleNoteUpdateWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, note) {
+      var postBody = note;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getFleetDevices");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling handleNoteUpdate");
       }
-      // verify the required parameter 'fleetUID' is set
-      if (fleetUID === undefined || fleetUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'fleetUID' when calling getFleetDevices");
+      // verify the required parameter 'deviceUID' is set
+      if (deviceUID === undefined || deviceUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling handleNoteUpdate");
+      }
+      // verify the required parameter 'notefileID' is set
+      if (notefileID === undefined || notefileID === null) {
+        throw new _Error["default"]("Missing the required parameter 'notefileID' when calling handleNoteUpdate");
+      }
+      // verify the required parameter 'noteID' is set
+      if (noteID === undefined || noteID === null) {
+        throw new _Error["default"]("Missing the required parameter 'noteID' when calling handleNoteUpdate");
+      }
+      // verify the required parameter 'note' is set
+      if (note === undefined || note === null) {
+        throw new _Error["default"]("Missing the required parameter 'note' when calling handleNoteUpdate");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'fleetUID': fleetUID
-      };
-      var queryParams = {
-        'pageSize': opts['pageSize'],
-        'pageNum': opts['pageNum'],
-        'deviceUID': this.apiClient.buildCollectionParam(opts['deviceUID'], 'multi'),
-        'tag': this.apiClient.buildCollectionParam(opts['tag'], 'multi'),
-        'serialNumber': this.apiClient.buildCollectionParam(opts['serialNumber'], 'multi'),
-        'notecardFirmware': this.apiClient.buildCollectionParam(opts['notecardFirmware'], 'multi'),
-        'location': this.apiClient.buildCollectionParam(opts['location'], 'multi'),
-        'hostFirmware': this.apiClient.buildCollectionParam(opts['hostFirmware'], 'multi'),
-        'productUID': this.apiClient.buildCollectionParam(opts['productUID'], 'multi'),
-        'sku': this.apiClient.buildCollectionParam(opts['sku'], 'multi')
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID,
+        notefileID: notefileID,
+        noteID: noteID
       };
+      var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
-      var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _GetDevices200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/fleets/{fleetUID}/devices', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var authNames = ["personalAccessToken"];
+      var contentTypes = ["application/json"];
+      var accepts = ["application/json"];
+      var returnType = null;
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/notes/{notefileID}/{noteID}", "PUT", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Get Devices of a Fleet within a Project
-     * @param {String} projectOrProductUID 
-     * @param {String} fleetUID 
-     * @param {Object} opts Optional parameters
-     * @param {Number} opts.pageSize  (default to 50)
-     * @param {Number} opts.pageNum  (default to 1)
-     * @param {Array.<String>} opts.deviceUID A Device UID.
-     * @param {Array.<String>} opts.tag Tag filter
-     * @param {Array.<String>} opts.serialNumber Serial number filter
-     * @param {Array.<String>} opts.notecardFirmware Firmware version filter
-     * @param {Array.<String>} opts.location Location filter
-     * @param {Array.<String>} opts.hostFirmware Host firmware filter
-     * @param {Array.<String>} opts.productUID 
-     * @param {Array.<String>} opts.sku SKU filter
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDevices200Response}
+     * Update a note in a DB notefile
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {String} notefileID
+     * @param {String} noteID
+     * @param {module:model/Note} note Body or payload of note to be added to the device
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
-    key: "getFleetDevices",
-    value: function getFleetDevices(projectOrProductUID, fleetUID, opts) {
-      return this.getFleetDevicesWithHttpInfo(projectOrProductUID, fleetUID, opts).then(function (response_and_data) {
+    key: "handleNoteUpdate",
+    value: function handleNoteUpdate(projectOrProductUID, deviceUID, notefileID, noteID, note) {
+      return this.handleNoteUpdateWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, note).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * For .qi files, returns the queued up notes.  For .db files, returns all notes in the notefile
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} notefileID 
+     * Used to perform queries on a single or multiple files to determine if new Notes are available to read
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
      * @param {Object} opts Optional parameters
-     * @param {String} opts.tracker The change tracker ID.
-     * @param {Number} opts.max The maximum number of Notes to return in the request.
-     * @param {Boolean} opts.start true to reset the tracker to the beginning.
-     * @param {Boolean} opts.stop true to delete the tracker.
-     * @param {Boolean} opts.deleted true to return deleted notes.
-     * @param {Boolean} opts._delete true to delete the notes returned by the request.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetNotefile200Response} and HTTP response
+     * @param {Array.<String>} opts.files One or more files to obtain change information from.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/HandleNotefileChanges200Response} and HTTP response
      */
   }, {
-    key: "getNotefileWithHttpInfo",
-    value: function getNotefileWithHttpInfo(projectOrProductUID, deviceUID, notefileID, opts) {
+    key: "handleNotefileChangesWithHttpInfo",
+    value: function handleNotefileChangesWithHttpInfo(projectOrProductUID, deviceUID, opts) {
       opts = opts || {};
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getNotefile");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling handleNotefileChanges");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getNotefile");
-      }
-      // verify the required parameter 'notefileID' is set
-      if (notefileID === undefined || notefileID === null) {
-        throw new _Error["default"]("Missing the required parameter 'notefileID' when calling getNotefile");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling handleNotefileChanges");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID,
-        'notefileID': notefileID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
       var queryParams = {
-        'tracker': opts['tracker'],
-        'max': opts['max'],
-        'start': opts['start'],
-        'stop': opts['stop'],
-        'deleted': opts['deleted'],
-        'delete': opts['_delete']
+        files: this.apiClient.buildCollectionParam(opts["files"], "multi")
       };
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _GetNotefile200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/notes/{notefileID}/changes', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _HandleNotefileChanges200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/files/changes", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * For .qi files, returns the queued up notes.  For .db files, returns all notes in the notefile
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} notefileID 
+     * Used to perform queries on a single or multiple files to determine if new Notes are available to read
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
      * @param {Object} opts Optional parameters
-     * @param {String} opts.tracker The change tracker ID.
-     * @param {Number} opts.max The maximum number of Notes to return in the request.
-     * @param {Boolean} opts.start true to reset the tracker to the beginning.
-     * @param {Boolean} opts.stop true to delete the tracker.
-     * @param {Boolean} opts.deleted true to return deleted notes.
-     * @param {Boolean} opts._delete true to delete the notes returned by the request.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetNotefile200Response}
+     * @param {Array.<String>} opts.files One or more files to obtain change information from.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/HandleNotefileChanges200Response}
      */
   }, {
-    key: "getNotefile",
-    value: function getNotefile(projectOrProductUID, deviceUID, notefileID, opts) {
-      return this.getNotefileWithHttpInfo(projectOrProductUID, deviceUID, notefileID, opts).then(function (response_and_data) {
+    key: "handleNotefileChanges",
+    value: function handleNotefileChanges(projectOrProductUID, deviceUID, opts) {
+      return this.handleNotefileChangesWithHttpInfo(projectOrProductUID, deviceUID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Lists .qi and .db files for the device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {Object} opts Optional parameters
-     * @param {String} opts.tracker The change tracker ID.
-     * @param {Array.<String>} opts.files One or more files to obtain change information from.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link Array.<module:model/Notefile>} and HTTP response
+     * Returns info about file changes that are pending upload to Notehub or download to the Notecard.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/HandleNotefileChangesPending200Response} and HTTP response
      */
   }, {
-    key: "listNotefilesWithHttpInfo",
-    value: function listNotefilesWithHttpInfo(projectOrProductUID, deviceUID, opts) {
-      opts = opts || {};
+    key: "handleNotefileChangesPendingWithHttpInfo",
+    value: function handleNotefileChangesPendingWithHttpInfo(projectOrProductUID, deviceUID) {
       var postBody = null;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling listNotefiles");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling handleNotefileChangesPending");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling listNotefiles");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling handleNotefileChangesPending");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
-      };
-      var queryParams = {
-        'tracker': opts['tracker'],
-        'files': this.apiClient.buildCollectionParam(opts['files'], 'multi')
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
+      var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
+      var authNames = ["personalAccessToken"];
       var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = [_Notefile["default"]];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/files', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var accepts = ["application/json"];
+      var returnType = _HandleNotefileChangesPending200Response["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/files/changes/pending", "GET", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Lists .qi and .db files for the device
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {Object} opts Optional parameters
-     * @param {String} opts.tracker The change tracker ID.
-     * @param {Array.<String>} opts.files One or more files to obtain change information from.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link Array.<module:model/Notefile>}
+     * Returns info about file changes that are pending upload to Notehub or download to the Notecard.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/HandleNotefileChangesPending200Response}
      */
   }, {
-    key: "listNotefiles",
-    value: function listNotefiles(projectOrProductUID, deviceUID, opts) {
-      return this.listNotefilesWithHttpInfo(projectOrProductUID, deviceUID, opts).then(function (response_and_data) {
+    key: "handleNotefileChangesPending",
+    value: function handleNotefileChangesPending(projectOrProductUID, deviceUID) {
+      return this.handleNotefileChangesPendingWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Lists .qi and .db files that are pending sync to the Notecard
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ListPendingNotefiles200Response} and HTTP response
+     * Deletes Notefiles and the Notes they contain.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {module:model/HandleNotefileDeleteRequest} handleNotefileDeleteRequest
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
-    key: "listPendingNotefilesWithHttpInfo",
-    value: function listPendingNotefilesWithHttpInfo(projectOrProductUID, deviceUID) {
-      var postBody = null;
+    key: "handleNotefileDeleteWithHttpInfo",
+    value: function handleNotefileDeleteWithHttpInfo(projectOrProductUID, deviceUID, handleNotefileDeleteRequest) {
+      var postBody = handleNotefileDeleteRequest;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling listPendingNotefiles");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling handleNotefileDelete");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling listPendingNotefiles");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling handleNotefileDelete");
+      }
+      // verify the required parameter 'handleNotefileDeleteRequest' is set
+      if (handleNotefileDeleteRequest === undefined || handleNotefileDeleteRequest === null) {
+        throw new _Error["default"]("Missing the required parameter 'handleNotefileDeleteRequest' when calling handleNotefileDelete");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
-      var contentTypes = [];
-      var accepts = ['application/json'];
-      var returnType = _ListPendingNotefiles200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/files/changes/pending', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var authNames = ["personalAccessToken"];
+      var contentTypes = ["application/json"];
+      var accepts = ["application/json"];
+      var returnType = null;
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/files", "DELETE", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Lists .qi and .db files that are pending sync to the Notecard
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ListPendingNotefiles200Response}
+     * Deletes Notefiles and the Notes they contain.
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {module:model/HandleNotefileDeleteRequest} handleNotefileDeleteRequest
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
-    key: "listPendingNotefiles",
-    value: function listPendingNotefiles(projectOrProductUID, deviceUID) {
-      return this.listPendingNotefilesWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    key: "handleNotefileDelete",
+    value: function handleNotefileDelete(projectOrProductUID, deviceUID, handleNotefileDeleteRequest) {
+      return this.handleNotefileDeleteWithHttpInfo(projectOrProductUID, deviceUID, handleNotefileDeleteRequest).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Provision Device for a Project
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {module:model/ProvisionDeviceRequest} provisionDeviceRequest Provision a device to a specific ProductUID
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {module:model/PostProvisionProjectDeviceRequest} postProvisionProjectDeviceRequest Provision a device to a specific ProductUID
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link Object} and HTTP response
      */
   }, {
-    key: "provisionDeviceWithHttpInfo",
-    value: function provisionDeviceWithHttpInfo(projectOrProductUID, deviceUID, provisionDeviceRequest) {
-      var postBody = provisionDeviceRequest;
+    key: "postProvisionProjectDeviceWithHttpInfo",
+    value: function postProvisionProjectDeviceWithHttpInfo(projectOrProductUID, deviceUID, postProvisionProjectDeviceRequest) {
+      var postBody = postProvisionProjectDeviceRequest;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling provisionDevice");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling postProvisionProjectDevice");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling provisionDevice");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling postProvisionProjectDevice");
       }
-      // verify the required parameter 'provisionDeviceRequest' is set
-      if (provisionDeviceRequest === undefined || provisionDeviceRequest === null) {
-        throw new _Error["default"]("Missing the required parameter 'provisionDeviceRequest' when calling provisionDevice");
+      // verify the required parameter 'postProvisionProjectDeviceRequest' is set
+      if (postProvisionProjectDeviceRequest === undefined || postProvisionProjectDeviceRequest === null) {
+        throw new _Error["default"]("Missing the required parameter 'postProvisionProjectDeviceRequest' when calling postProvisionProjectDevice");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
-      var contentTypes = ['application/json'];
-      var accepts = ['application/json'];
+      var authNames = ["personalAccessToken"];
+      var contentTypes = ["application/json"];
+      var accepts = ["application/json"];
       var returnType = Object;
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/provision', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/provision", "POST", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Provision Device for a Project
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {module:model/ProvisionDeviceRequest} provisionDeviceRequest Provision a device to a specific ProductUID
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {module:model/PostProvisionProjectDeviceRequest} postProvisionProjectDeviceRequest Provision a device to a specific ProductUID
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link Object}
      */
   }, {
-    key: "provisionDevice",
-    value: function provisionDevice(projectOrProductUID, deviceUID, provisionDeviceRequest) {
-      return this.provisionDeviceWithHttpInfo(projectOrProductUID, deviceUID, provisionDeviceRequest).then(function (response_and_data) {
+    key: "postProvisionProjectDevice",
+    value: function postProvisionProjectDevice(projectOrProductUID, deviceUID, postProvisionProjectDeviceRequest) {
+      return this.postProvisionProjectDeviceWithHttpInfo(projectOrProductUID, deviceUID, postProvisionProjectDeviceRequest).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Send a signal from Notehub to a Notecard.
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {module:model/Body} body Body or payload of signal to be sent to the device
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/SignalDevice200Response} and HTTP response
+     * Put environment variables of a device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {module:model/EnvironmentVariables} environmentVariables Environment variables to be added to the device
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EnvironmentVariables} and HTTP response
      */
   }, {
-    key: "signalDeviceWithHttpInfo",
-    value: function signalDeviceWithHttpInfo(projectOrProductUID, deviceUID, body) {
-      var postBody = body;
+    key: "putDeviceEnvironmentVariablesWithHttpInfo",
+    value: function putDeviceEnvironmentVariablesWithHttpInfo(projectOrProductUID, deviceUID, environmentVariables) {
+      var postBody = environmentVariables;
       // verify the required parameter 'projectOrProductUID' is set
       if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling signalDevice");
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling putDeviceEnvironmentVariables");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling signalDevice");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling putDeviceEnvironmentVariables");
       }
-      // verify the required parameter 'body' is set
-      if (body === undefined || body === null) {
-        throw new _Error["default"]("Missing the required parameter 'body' when calling signalDevice");
+      // verify the required parameter 'environmentVariables' is set
+      if (environmentVariables === undefined || environmentVariables === null) {
+        throw new _Error["default"]("Missing the required parameter 'environmentVariables' when calling putDeviceEnvironmentVariables");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID
+        projectOrProductUID: projectOrProductUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
-      var contentTypes = ['application/json'];
-      var accepts = ['application/json'];
-      var returnType = _SignalDevice200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/signal', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var authNames = ["personalAccessToken"];
+      var contentTypes = ["application/json"];
+      var accepts = ["application/json"];
+      var returnType = _EnvironmentVariables["default"];
+      return this.apiClient.callApi("/v1/projects/{projectOrProductUID}/devices/{deviceUID}/environment_variables", "PUT", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Send a signal from Notehub to a Notecard.
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {module:model/Body} body Body or payload of signal to be sent to the device
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/SignalDevice200Response}
+     * Put environment variables of a device
+     * @param {String} projectOrProductUID
+     * @param {String} deviceUID
+     * @param {module:model/EnvironmentVariables} environmentVariables Environment variables to be added to the device
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EnvironmentVariables}
      */
   }, {
-    key: "signalDevice",
-    value: function signalDevice(projectOrProductUID, deviceUID, body) {
-      return this.signalDeviceWithHttpInfo(projectOrProductUID, deviceUID, body).then(function (response_and_data) {
+    key: "putDeviceEnvironmentVariables",
+    value: function putDeviceEnvironmentVariables(projectOrProductUID, deviceUID, environmentVariables) {
+      return this.putDeviceEnvironmentVariablesWithHttpInfo(projectOrProductUID, deviceUID, environmentVariables).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Update a note in a .db notefile
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} notefileID 
-     * @param {String} noteID 
-     * @param {module:model/Note} note Body or payload of note to be added to the device
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
+     * Put environment variables of a device with device pin authorization
+     * @param {String} productUID
+     * @param {String} deviceUID
+     * @param {module:model/EnvironmentVariables} environmentVariables Environment variables to be added to the device
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EnvironmentVariables} and HTTP response
      */
   }, {
-    key: "updateDbNoteWithHttpInfo",
-    value: function updateDbNoteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, note) {
-      var postBody = note;
-      // verify the required parameter 'projectOrProductUID' is set
-      if (projectOrProductUID === undefined || projectOrProductUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling updateDbNote");
+    key: "putDeviceEnvironmentVariablesByPinWithHttpInfo",
+    value: function putDeviceEnvironmentVariablesByPinWithHttpInfo(productUID, deviceUID, environmentVariables) {
+      var postBody = environmentVariables;
+      // verify the required parameter 'productUID' is set
+      if (productUID === undefined || productUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'productUID' when calling putDeviceEnvironmentVariablesByPin");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling updateDbNote");
+        throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling putDeviceEnvironmentVariablesByPin");
       }
-      // verify the required parameter 'notefileID' is set
-      if (notefileID === undefined || notefileID === null) {
-        throw new _Error["default"]("Missing the required parameter 'notefileID' when calling updateDbNote");
-      }
-      // verify the required parameter 'noteID' is set
-      if (noteID === undefined || noteID === null) {
-        throw new _Error["default"]("Missing the required parameter 'noteID' when calling updateDbNote");
-      }
-      // verify the required parameter 'note' is set
-      if (note === undefined || note === null) {
-        throw new _Error["default"]("Missing the required parameter 'note' when calling updateDbNote");
+      // verify the required parameter 'environmentVariables' is set
+      if (environmentVariables === undefined || environmentVariables === null) {
+        throw new _Error["default"]("Missing the required parameter 'environmentVariables' when calling putDeviceEnvironmentVariablesByPin");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
-        'deviceUID': deviceUID,
-        'notefileID': notefileID,
-        'noteID': noteID
+        productUID: productUID,
+        deviceUID: deviceUID
       };
       var queryParams = {};
       var headerParams = {};
       var formParams = {};
-      var authNames = ['personalAccessToken'];
-      var contentTypes = ['application/json'];
-      var accepts = ['application/json'];
-      var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/notes/{notefileID}/{noteID}', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var authNames = ["pin"];
+      var contentTypes = ["application/json"];
+      var accepts = ["application/json"];
+      var returnType = _EnvironmentVariables["default"];
+      return this.apiClient.callApi("/v1/products/{productUID}/devices/{deviceUID}/environment_variables_with_pin", "PUT", pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Update a note in a .db notefile
-     * @param {String} projectOrProductUID 
-     * @param {String} deviceUID 
-     * @param {String} notefileID 
-     * @param {String} noteID 
-     * @param {module:model/Note} note Body or payload of note to be added to the device
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}
+     * Put environment variables of a device with device pin authorization
+     * @param {String} productUID
+     * @param {String} deviceUID
+     * @param {module:model/EnvironmentVariables} environmentVariables Environment variables to be added to the device
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EnvironmentVariables}
      */
   }, {
-    key: "updateDbNote",
-    value: function updateDbNote(projectOrProductUID, deviceUID, notefileID, noteID, note) {
-      return this.updateDbNoteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, note).then(function (response_and_data) {
+    key: "putDeviceEnvironmentVariablesByPin",
+    value: function putDeviceEnvironmentVariablesByPin(productUID, deviceUID, environmentVariables) {
+      return this.putDeviceEnvironmentVariablesByPinWithHttpInfo(productUID, deviceUID, environmentVariables).then(function (response_and_data) {
         return response_and_data.data;
       });
     }