@blues-inc/notehub-js 1.0.33-beta.1 → 1.0.33-beta.2

package/dist/api/DeviceApi.js

@@ -45,7 +45,7 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 /**
 * Device service.
 * @module api/DeviceApi
-* @version 1.0.33-beta.1
+* @version 1.0.33-beta.2
 */
 var DeviceApi = exports["default"] = /*#__PURE__*/function () {
   /**
@@ -62,18 +62,18 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
 
   /**
    * Delete environment variable of a device
-   * @param {String} projectOrProductUID 
+   * @param {String} projectUID 
    * @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: "deleteDeviceEnvironmentVariableWithHttpInfo",
-    value: function deleteDeviceEnvironmentVariableWithHttpInfo(projectOrProductUID, deviceUID, key) {
+    value: function deleteDeviceEnvironmentVariableWithHttpInfo(projectUID, 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 deleteDeviceEnvironmentVariable");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling deleteDeviceEnvironmentVariable");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -84,7 +84,7 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'key' when calling deleteDeviceEnvironmentVariable");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID,
         'key': key
       };
@@ -95,38 +95,38 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/environment_variables/{key}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Delete environment variable of a device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @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: "deleteDeviceEnvironmentVariable",
-    value: function deleteDeviceEnvironmentVariable(projectOrProductUID, deviceUID, key) {
-      return this.deleteDeviceEnvironmentVariableWithHttpInfo(projectOrProductUID, deviceUID, key).then(function (response_and_data) {
+    value: function deleteDeviceEnvironmentVariable(projectUID, deviceUID, key) {
+      return this.deleteDeviceEnvironmentVariableWithHttpInfo(projectUID, deviceUID, key).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Delete Device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {Boolean} purge 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
     key: "deleteProjectDeviceWithHttpInfo",
-    value: function deleteProjectDeviceWithHttpInfo(projectOrProductUID, deviceUID, purge) {
+    value: function deleteProjectDeviceWithHttpInfo(projectUID, 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 deleteProjectDevice");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling deleteProjectDevice");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -137,7 +137,7 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'purge' when calling deleteProjectDevice");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {
@@ -149,44 +149,44 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Delete Device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {Boolean} purge 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
     key: "deleteProjectDevice",
-    value: function deleteProjectDevice(projectOrProductUID, deviceUID, purge) {
-      return this.deleteProjectDeviceWithHttpInfo(projectOrProductUID, deviceUID, purge).then(function (response_and_data) {
+    value: function deleteProjectDevice(projectUID, deviceUID, purge) {
+      return this.deleteProjectDeviceWithHttpInfo(projectUID, deviceUID, purge).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Disable Device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
     key: "disableDeviceWithHttpInfo",
-    value: function disableDeviceWithHttpInfo(projectOrProductUID, deviceUID) {
+    value: function disableDeviceWithHttpInfo(projectUID, 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 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' 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 disableDevice");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -196,43 +196,43 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/disable', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Disable Device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
     key: "disableDevice",
-    value: function disableDevice(projectOrProductUID, deviceUID) {
-      return this.disableDeviceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    value: function disableDevice(projectUID, deviceUID) {
+      return this.disableDeviceWithHttpInfo(projectUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Disable Connectivity Assurance
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
     key: "disableDeviceConnectivityAssuranceWithHttpInfo",
-    value: function disableDeviceConnectivityAssuranceWithHttpInfo(projectOrProductUID, deviceUID) {
+    value: function disableDeviceConnectivityAssuranceWithHttpInfo(projectUID, 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 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' 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 disableDeviceConnectivityAssurance");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -242,43 +242,43 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/disable-connectivity-assurance', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Disable Connectivity Assurance
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
     key: "disableDeviceConnectivityAssurance",
-    value: function disableDeviceConnectivityAssurance(projectOrProductUID, deviceUID) {
-      return this.disableDeviceConnectivityAssuranceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    value: function disableDeviceConnectivityAssurance(projectUID, deviceUID) {
+      return this.disableDeviceConnectivityAssuranceWithHttpInfo(projectUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Enable Device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
     key: "enableDeviceWithHttpInfo",
-    value: function enableDeviceWithHttpInfo(projectOrProductUID, deviceUID) {
+    value: function enableDeviceWithHttpInfo(projectUID, 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 enableDevice");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' 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 enableDevice");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -288,43 +288,43 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/enable', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Enable Device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
     key: "enableDevice",
-    value: function enableDevice(projectOrProductUID, deviceUID) {
-      return this.enableDeviceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    value: function enableDevice(projectUID, deviceUID) {
+      return this.enableDeviceWithHttpInfo(projectUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Enable Connectivity Assurance
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
     key: "enableDeviceConnectivityAssuranceWithHttpInfo",
-    value: function enableDeviceConnectivityAssuranceWithHttpInfo(projectOrProductUID, deviceUID) {
+    value: function enableDeviceConnectivityAssuranceWithHttpInfo(projectUID, 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");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' 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 enableDeviceConnectivityAssurance");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -334,43 +334,43 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/enable-connectivity-assurance', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Enable Connectivity Assurance
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
     key: "enableDeviceConnectivityAssurance",
-    value: function enableDeviceConnectivityAssurance(projectOrProductUID, deviceUID) {
-      return this.enableDeviceConnectivityAssuranceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    value: function enableDeviceConnectivityAssurance(projectUID, deviceUID) {
+      return this.enableDeviceConnectivityAssuranceWithHttpInfo(projectUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @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: "getDeviceWithHttpInfo",
-    value: function getDeviceWithHttpInfo(projectOrProductUID, deviceUID) {
+    value: function getDeviceWithHttpInfo(projectUID, 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");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' 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 getDevice");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -380,43 +380,43 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Device}
      */
   }, {
     key: "getDevice",
-    value: function getDevice(projectOrProductUID, deviceUID) {
-      return this.getDeviceWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    value: function getDevice(projectUID, deviceUID) {
+      return this.getDeviceWithHttpInfo(projectUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get environment variables of a device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDeviceEnvironmentVariables200Response} and HTTP response
      */
   }, {
     key: "getDeviceEnvironmentVariablesWithHttpInfo",
-    value: function getDeviceEnvironmentVariablesWithHttpInfo(projectOrProductUID, deviceUID) {
+    value: function getDeviceEnvironmentVariablesWithHttpInfo(projectUID, 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 getDeviceEnvironmentVariables");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' 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");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -426,19 +426,19 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _GetDeviceEnvironmentVariables200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/environment_variables', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/environment_variables', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get environment variables of a device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceEnvironmentVariables200Response}
      */
   }, {
     key: "getDeviceEnvironmentVariables",
-    value: function getDeviceEnvironmentVariables(projectOrProductUID, deviceUID) {
-      return this.getDeviceEnvironmentVariablesWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    value: function getDeviceEnvironmentVariables(projectUID, deviceUID) {
+      return this.getDeviceEnvironmentVariablesWithHttpInfo(projectUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -491,24 +491,24 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Get Device Health Log
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetDeviceHealthLog200Response} and HTTP response
      */
   }, {
     key: "getDeviceHealthLogWithHttpInfo",
-    value: function getDeviceHealthLogWithHttpInfo(projectOrProductUID, deviceUID) {
+    value: function getDeviceHealthLogWithHttpInfo(projectUID, 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 getDeviceHealthLog");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' 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 getDeviceHealthLog");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -518,43 +518,43 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/health-log', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Device Health Log
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceHealthLog200Response}
      */
   }, {
     key: "getDeviceHealthLog",
-    value: function getDeviceHealthLog(projectOrProductUID, deviceUID) {
-      return this.getDeviceHealthLogWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    value: function getDeviceHealthLog(projectUID, deviceUID) {
+      return this.getDeviceHealthLogWithHttpInfo(projectUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Device Latest Events
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @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: "getDeviceLatestWithHttpInfo",
-    value: function getDeviceLatestWithHttpInfo(projectOrProductUID, deviceUID) {
+    value: function getDeviceLatestWithHttpInfo(projectUID, 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 getDeviceLatest");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' 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 getDeviceLatest");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -564,43 +564,43 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/latest', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Device Latest Events
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDeviceLatest200Response}
      */
   }, {
     key: "getDeviceLatest",
-    value: function getDeviceLatest(projectOrProductUID, deviceUID) {
-      return this.getDeviceLatestWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    value: function getDeviceLatest(projectUID, deviceUID) {
+      return this.getDeviceLatestWithHttpInfo(projectUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Device Public Key
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @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: "getDevicePublicKeyWithHttpInfo",
-    value: function getDevicePublicKeyWithHttpInfo(projectOrProductUID, deviceUID) {
+    value: function getDevicePublicKeyWithHttpInfo(projectUID, 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 getDevicePublicKey");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' 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 getDevicePublicKey");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -610,26 +610,26 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/public-key', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Device Public Key
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetDevicePublicKey200Response}
      */
   }, {
     key: "getDevicePublicKey",
-    value: function getDevicePublicKey(projectOrProductUID, deviceUID) {
-      return this.getDevicePublicKeyWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    value: function getDevicePublicKey(projectUID, deviceUID) {
+      return this.getDevicePublicKeyWithHttpInfo(projectUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Device Sessions
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.pageSize  (default to 50)
@@ -638,19 +638,19 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getDeviceSessionsWithHttpInfo",
-    value: function getDeviceSessionsWithHttpInfo(projectOrProductUID, deviceUID, opts) {
+    value: function getDeviceSessionsWithHttpInfo(projectUID, 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 getDeviceSessions");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' 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 getDeviceSessions");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {
@@ -663,12 +663,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/sessions', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Device Sessions
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.pageSize  (default to 50)
@@ -677,15 +677,15 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getDeviceSessions",
-    value: function getDeviceSessions(projectOrProductUID, deviceUID, opts) {
-      return this.getDeviceSessionsWithHttpInfo(projectOrProductUID, deviceUID, opts).then(function (response_and_data) {
+    value: function getDeviceSessions(projectUID, deviceUID, opts) {
+      return this.getDeviceSessionsWithHttpInfo(projectUID, deviceUID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Device Public Keys of a Project
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.pageSize  (default to 50)
      * @param {Number} opts.pageNum  (default to 1)
@@ -693,15 +693,15 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getProjectDevicePublicKeysWithHttpInfo",
-    value: function getProjectDevicePublicKeysWithHttpInfo(projectOrProductUID, opts) {
+    value: function getProjectDevicePublicKeysWithHttpInfo(projectUID, 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 getProjectDevicePublicKeys");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getProjectDevicePublicKeys");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID
+        'projectUID': projectUID
       };
       var queryParams = {
         'pageSize': opts['pageSize'],
@@ -713,12 +713,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/public-keys', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Device Public Keys of a Project
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.pageSize  (default to 50)
      * @param {Number} opts.pageNum  (default to 1)
@@ -726,15 +726,15 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getProjectDevicePublicKeys",
-    value: function getProjectDevicePublicKeys(projectOrProductUID, opts) {
-      return this.getProjectDevicePublicKeysWithHttpInfo(projectOrProductUID, opts).then(function (response_and_data) {
+    value: function getProjectDevicePublicKeys(projectUID, opts) {
+      return this.getProjectDevicePublicKeysWithHttpInfo(projectUID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Devices of a Project
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.pageSize  (default to 50)
      * @param {Number} opts.pageNum  (default to 1)
@@ -751,15 +751,15 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getProjectDevicesWithHttpInfo",
-    value: function getProjectDevicesWithHttpInfo(projectOrProductUID, opts) {
+    value: function getProjectDevicesWithHttpInfo(projectUID, 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 getProjectDevices");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getProjectDevices");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID
+        'projectUID': projectUID
       };
       var queryParams = {
         'pageSize': opts['pageSize'],
@@ -780,12 +780,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Devices of a Project
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.pageSize  (default to 50)
      * @param {Number} opts.pageNum  (default to 1)
@@ -802,15 +802,15 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getProjectDevices",
-    value: function getProjectDevices(projectOrProductUID, opts) {
-      return this.getProjectDevicesWithHttpInfo(projectOrProductUID, opts).then(function (response_and_data) {
+    value: function getProjectDevices(projectUID, opts) {
+      return this.getProjectDevicesWithHttpInfo(projectUID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Devices of a Fleet within a Project
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} fleetUID 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.pageSize  (default to 50)
@@ -827,19 +827,19 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getProjectFleetDevicesWithHttpInfo",
-    value: function getProjectFleetDevicesWithHttpInfo(projectOrProductUID, fleetUID, opts) {
+    value: function getProjectFleetDevicesWithHttpInfo(projectUID, 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 getProjectFleetDevices");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getProjectFleetDevices");
       }
       // 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,
+        'projectUID': projectUID,
         'fleetUID': fleetUID
       };
       var queryParams = {
@@ -860,12 +860,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/fleets/{fleetUID}/devices', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Devices of a Fleet within a Project
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} fleetUID 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.pageSize  (default to 50)
@@ -882,15 +882,15 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getProjectFleetDevices",
-    value: function getProjectFleetDevices(projectOrProductUID, fleetUID, opts) {
-      return this.getProjectFleetDevicesWithHttpInfo(projectOrProductUID, fleetUID, opts).then(function (response_and_data) {
+    value: function getProjectFleetDevices(projectUID, fleetUID, opts) {
+      return this.getProjectFleetDevicesWithHttpInfo(projectUID, fleetUID, opts).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} projectUID 
      * @param {String} deviceUID 
      * @param {String} notefileID 
      * @param {module:model/Note} note Body or payload of note to be added to the device
@@ -898,11 +898,11 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNoteAddWithHttpInfo",
-    value: function handleNoteAddWithHttpInfo(projectOrProductUID, deviceUID, notefileID, note) {
+    value: function handleNoteAddWithHttpInfo(projectUID, 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 handleNoteAdd");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling handleNoteAdd");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -917,7 +917,7 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'note' when calling handleNoteAdd");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID,
         'notefileID': notefileID
       };
@@ -928,12 +928,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/notes/{notefileID}', '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} projectUID 
      * @param {String} deviceUID 
      * @param {String} notefileID 
      * @param {module:model/Note} note Body or payload of note to be added to the device
@@ -941,15 +941,15 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNoteAdd",
-    value: function handleNoteAdd(projectOrProductUID, deviceUID, notefileID, note) {
-      return this.handleNoteAddWithHttpInfo(projectOrProductUID, deviceUID, notefileID, note).then(function (response_and_data) {
+    value: function handleNoteAdd(projectUID, deviceUID, notefileID, note) {
+      return this.handleNoteAddWithHttpInfo(projectUID, deviceUID, notefileID, note).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Incrementally retrieve changes within a specific Notefile.
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {String} notefileID 
      * @param {Object} opts Optional parameters
@@ -963,12 +963,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNoteChangesWithHttpInfo",
-    value: function handleNoteChangesWithHttpInfo(projectOrProductUID, deviceUID, notefileID, opts) {
+    value: function handleNoteChangesWithHttpInfo(projectUID, 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 handleNoteChanges");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling handleNoteChanges");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -979,7 +979,7 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'notefileID' when calling handleNoteChanges");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID,
         'notefileID': notefileID
       };
@@ -997,12 +997,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/notes/{notefileID}/changes', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Incrementally retrieve changes within a specific Notefile.
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {String} notefileID 
      * @param {Object} opts Optional parameters
@@ -1016,15 +1016,15 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNoteChanges",
-    value: function handleNoteChanges(projectOrProductUID, deviceUID, notefileID, opts) {
-      return this.handleNoteChangesWithHttpInfo(projectOrProductUID, deviceUID, notefileID, opts).then(function (response_and_data) {
+    value: function handleNoteChanges(projectUID, deviceUID, notefileID, opts) {
+      return this.handleNoteChangesWithHttpInfo(projectUID, deviceUID, notefileID, opts).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} projectUID 
      * @param {String} deviceUID 
      * @param {String} notefileID 
      * @param {String} noteID 
@@ -1033,11 +1033,11 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNoteCreateAddWithHttpInfo",
-    value: function handleNoteCreateAddWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, note) {
+    value: function handleNoteCreateAddWithHttpInfo(projectUID, 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 handleNoteCreateAdd");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling handleNoteCreateAdd");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -1056,7 +1056,7 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'note' when calling handleNoteCreateAdd");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID,
         'notefileID': notefileID,
         'noteID': noteID
@@ -1068,12 +1068,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/notes/{notefileID}/{noteID}', '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} projectUID 
      * @param {String} deviceUID 
      * @param {String} notefileID 
      * @param {String} noteID 
@@ -1082,15 +1082,15 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNoteCreateAdd",
-    value: function handleNoteCreateAdd(projectOrProductUID, deviceUID, notefileID, noteID, note) {
-      return this.handleNoteCreateAddWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, note).then(function (response_and_data) {
+    value: function handleNoteCreateAdd(projectUID, deviceUID, notefileID, noteID, note) {
+      return this.handleNoteCreateAddWithHttpInfo(projectUID, deviceUID, notefileID, noteID, note).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Delete a note from a DB notefile
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {String} notefileID 
      * @param {String} noteID 
@@ -1098,11 +1098,11 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNoteDeleteWithHttpInfo",
-    value: function handleNoteDeleteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID) {
+    value: function handleNoteDeleteWithHttpInfo(projectUID, 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 handleNoteDelete");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling handleNoteDelete");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -1117,7 +1117,7 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'noteID' when calling handleNoteDelete");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID,
         'notefileID': notefileID,
         'noteID': noteID
@@ -1129,12 +1129,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       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/{projectUID}/devices/{deviceUID}/notes/{notefileID}/{noteID}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Delete a note from a DB notefile
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {String} notefileID 
      * @param {String} noteID 
@@ -1142,15 +1142,15 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNoteDelete",
-    value: function handleNoteDelete(projectOrProductUID, deviceUID, notefileID, noteID) {
-      return this.handleNoteDeleteWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID).then(function (response_and_data) {
+    value: function handleNoteDelete(projectUID, deviceUID, notefileID, noteID) {
+      return this.handleNoteDeleteWithHttpInfo(projectUID, deviceUID, notefileID, noteID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get a note from a DB notefile
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {String} notefileID 
      * @param {String} noteID 
@@ -1161,12 +1161,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNoteGetWithHttpInfo",
-    value: function handleNoteGetWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, opts) {
+    value: function handleNoteGetWithHttpInfo(projectUID, 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 handleNoteGet");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling handleNoteGet");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -1181,7 +1181,7 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'noteID' when calling handleNoteGet");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID,
         'notefileID': notefileID,
         'noteID': noteID
@@ -1196,12 +1196,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/notes/{notefileID}/{noteID}', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get a note from a DB notefile
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {String} notefileID 
      * @param {String} noteID 
@@ -1212,26 +1212,26 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNoteGet",
-    value: function handleNoteGet(projectOrProductUID, deviceUID, notefileID, noteID, opts) {
-      return this.handleNoteGetWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, opts).then(function (response_and_data) {
+    value: function handleNoteGet(projectUID, deviceUID, notefileID, noteID, opts) {
+      return this.handleNoteGetWithHttpInfo(projectUID, deviceUID, notefileID, noteID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Send a signal from Notehub to a Notecard.
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @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: "handleNoteSignalWithHttpInfo",
-    value: function handleNoteSignalWithHttpInfo(projectOrProductUID, deviceUID, body) {
+    value: function handleNoteSignalWithHttpInfo(projectUID, 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 handleNoteSignal");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling handleNoteSignal");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -1242,7 +1242,7 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'body' when calling handleNoteSignal");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -1252,27 +1252,27 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/signal', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Send a signal from Notehub to a Notecard.
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @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: "handleNoteSignal",
-    value: function handleNoteSignal(projectOrProductUID, deviceUID, body) {
-      return this.handleNoteSignalWithHttpInfo(projectOrProductUID, deviceUID, body).then(function (response_and_data) {
+    value: function handleNoteSignal(projectUID, deviceUID, body) {
+      return this.handleNoteSignalWithHttpInfo(projectUID, deviceUID, body).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Update a note in a DB notefile
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {String} notefileID 
      * @param {String} noteID 
@@ -1281,11 +1281,11 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNoteUpdateWithHttpInfo",
-    value: function handleNoteUpdateWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, note) {
+    value: function handleNoteUpdateWithHttpInfo(projectUID, 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 handleNoteUpdate");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling handleNoteUpdate");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -1304,7 +1304,7 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'note' when calling handleNoteUpdate");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID,
         'notefileID': notefileID,
         'noteID': noteID
@@ -1316,12 +1316,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/notes/{notefileID}/{noteID}', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Update a note in a DB notefile
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {String} notefileID 
      * @param {String} noteID 
@@ -1330,15 +1330,15 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNoteUpdate",
-    value: function handleNoteUpdate(projectOrProductUID, deviceUID, notefileID, noteID, note) {
-      return this.handleNoteUpdateWithHttpInfo(projectOrProductUID, deviceUID, notefileID, noteID, note).then(function (response_and_data) {
+    value: function handleNoteUpdate(projectUID, deviceUID, notefileID, noteID, note) {
+      return this.handleNoteUpdateWithHttpInfo(projectUID, deviceUID, notefileID, noteID, note).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Used to perform queries on a single or multiple files to determine if new Notes are available to read
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {Object} opts Optional parameters
      * @param {String} opts.tracker The change tracker ID.
@@ -1347,19 +1347,19 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNotefileChangesWithHttpInfo",
-    value: function handleNotefileChangesWithHttpInfo(projectOrProductUID, deviceUID, opts) {
+    value: function handleNotefileChangesWithHttpInfo(projectUID, 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 handleNotefileChanges");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' 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 handleNotefileChanges");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {
@@ -1372,12 +1372,12 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/files/changes', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Used to perform queries on a single or multiple files to determine if new Notes are available to read
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {Object} opts Optional parameters
      * @param {String} opts.tracker The change tracker ID.
@@ -1386,32 +1386,32 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "handleNotefileChanges",
-    value: function handleNotefileChanges(projectOrProductUID, deviceUID, opts) {
-      return this.handleNotefileChangesWithHttpInfo(projectOrProductUID, deviceUID, opts).then(function (response_and_data) {
+    value: function handleNotefileChanges(projectUID, deviceUID, opts) {
+      return this.handleNotefileChangesWithHttpInfo(projectUID, deviceUID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Returns info about file changes that are pending upload to Notehub or download to the Notecard.
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @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: "handleNotefileChangesPendingWithHttpInfo",
-    value: function handleNotefileChangesPendingWithHttpInfo(projectOrProductUID, deviceUID) {
+    value: function handleNotefileChangesPendingWithHttpInfo(projectUID, 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 handleNotefileChangesPending");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' 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 handleNotefileChangesPending");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -1421,37 +1421,37 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/files/changes/pending', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Returns info about file changes that are pending upload to Notehub or download to the Notecard.
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/HandleNotefileChangesPending200Response}
      */
   }, {
     key: "handleNotefileChangesPending",
-    value: function handleNotefileChangesPending(projectOrProductUID, deviceUID) {
-      return this.handleNotefileChangesPendingWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
+    value: function handleNotefileChangesPending(projectUID, deviceUID) {
+      return this.handleNotefileChangesPendingWithHttpInfo(projectUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Deletes Notefiles and the Notes they contain.
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {module:model/HandleNotefileDeleteRequest} handleNotefileDeleteRequest 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
     key: "handleNotefileDeleteWithHttpInfo",
-    value: function handleNotefileDeleteWithHttpInfo(projectOrProductUID, deviceUID, handleNotefileDeleteRequest) {
+    value: function handleNotefileDeleteWithHttpInfo(projectUID, 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 handleNotefileDelete");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling handleNotefileDelete");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -1462,7 +1462,7 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'handleNotefileDeleteRequest' when calling handleNotefileDelete");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -1472,38 +1472,38 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/files', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Deletes Notefiles and the Notes they contain.
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @param {String} deviceUID 
      * @param {module:model/HandleNotefileDeleteRequest} handleNotefileDeleteRequest 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
     key: "handleNotefileDelete",
-    value: function handleNotefileDelete(projectOrProductUID, deviceUID, handleNotefileDeleteRequest) {
-      return this.handleNotefileDeleteWithHttpInfo(projectOrProductUID, deviceUID, handleNotefileDeleteRequest).then(function (response_and_data) {
+    value: function handleNotefileDelete(projectUID, deviceUID, handleNotefileDeleteRequest) {
+      return this.handleNotefileDeleteWithHttpInfo(projectUID, deviceUID, handleNotefileDeleteRequest).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Provision Device for a Project
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @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: "postProvisionProjectDeviceWithHttpInfo",
-    value: function postProvisionProjectDeviceWithHttpInfo(projectOrProductUID, deviceUID, postProvisionProjectDeviceRequest) {
+    value: function postProvisionProjectDeviceWithHttpInfo(projectUID, 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 postProvisionProjectDevice");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling postProvisionProjectDevice");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -1514,7 +1514,7 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'postProvisionProjectDeviceRequest' when calling postProvisionProjectDevice");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -1524,38 +1524,38 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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/{projectUID}/devices/{deviceUID}/provision', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Provision Device for a Project
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @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: "postProvisionProjectDevice",
-    value: function postProvisionProjectDevice(projectOrProductUID, deviceUID, postProvisionProjectDeviceRequest) {
-      return this.postProvisionProjectDeviceWithHttpInfo(projectOrProductUID, deviceUID, postProvisionProjectDeviceRequest).then(function (response_and_data) {
+    value: function postProvisionProjectDevice(projectUID, deviceUID, postProvisionProjectDeviceRequest) {
+      return this.postProvisionProjectDeviceWithHttpInfo(projectUID, deviceUID, postProvisionProjectDeviceRequest).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Put environment variables of a device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @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: "putDeviceEnvironmentVariablesWithHttpInfo",
-    value: function putDeviceEnvironmentVariablesWithHttpInfo(projectOrProductUID, deviceUID, environmentVariables) {
+    value: function putDeviceEnvironmentVariablesWithHttpInfo(projectUID, 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 putDeviceEnvironmentVariables");
+      // verify the required parameter 'projectUID' is set
+      if (projectUID === undefined || projectUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling putDeviceEnvironmentVariables");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -1566,7 +1566,7 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'environmentVariables' when calling putDeviceEnvironmentVariables");
       }
       var pathParams = {
-        'projectOrProductUID': projectOrProductUID,
+        'projectUID': projectUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -1576,20 +1576,20 @@ var DeviceApi = exports["default"] = /*#__PURE__*/function () {
       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);
+      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/environment_variables', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Put environment variables of a device
-     * @param {String} projectOrProductUID 
+     * @param {String} projectUID 
      * @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: "putDeviceEnvironmentVariables",
-    value: function putDeviceEnvironmentVariables(projectOrProductUID, deviceUID, environmentVariables) {
-      return this.putDeviceEnvironmentVariablesWithHttpInfo(projectOrProductUID, deviceUID, environmentVariables).then(function (response_and_data) {
+    value: function putDeviceEnvironmentVariables(projectUID, deviceUID, environmentVariables) {
+      return this.putDeviceEnvironmentVariablesWithHttpInfo(projectUID, deviceUID, environmentVariables).then(function (response_and_data) {
         return response_and_data.data;
       });
     }