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

package/dist/api/ProjectApi.js

@@ -49,7 +49,7 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 /**
 * Project service.
 * @module api/ProjectApi
-* @version 1.0.33-beta.2
+* @version 1.0.33-beta.4
 */
 var ProjectApi = exports["default"] = /*#__PURE__*/function () {
   /**
@@ -66,24 +66,24 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
 
   /**
    * Clone a Project
-   * @param {String} projectUID The project UID to be cloned.
+   * @param {String} projectOrProductUID 
    * @param {module:model/CloneProjectRequest} cloneProjectRequest Project to be cloned
    * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Project} and HTTP response
    */
   return _createClass(ProjectApi, [{
     key: "cloneProjectWithHttpInfo",
-    value: function cloneProjectWithHttpInfo(projectUID, cloneProjectRequest) {
+    value: function cloneProjectWithHttpInfo(projectOrProductUID, cloneProjectRequest) {
       var postBody = cloneProjectRequest;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling cloneProject");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling cloneProject");
       }
       // verify the required parameter 'cloneProjectRequest' is set
       if (cloneProjectRequest === undefined || cloneProjectRequest === null) {
         throw new _Error["default"]("Missing the required parameter 'cloneProjectRequest' when calling cloneProject");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -92,43 +92,43 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = ['application/json'];
       var accepts = ['application/json'];
       var returnType = _Project["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/clone', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/clone', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Clone a Project
-     * @param {String} projectUID The project UID to be cloned.
+     * @param {String} projectOrProductUID 
      * @param {module:model/CloneProjectRequest} cloneProjectRequest Project to be cloned
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Project}
      */
   }, {
     key: "cloneProject",
-    value: function cloneProject(projectUID, cloneProjectRequest) {
-      return this.cloneProjectWithHttpInfo(projectUID, cloneProjectRequest).then(function (response_and_data) {
+    value: function cloneProject(projectOrProductUID, cloneProjectRequest) {
+      return this.cloneProjectWithHttpInfo(projectOrProductUID, cloneProjectRequest).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Create Fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {module:model/CreateFleetRequest} createFleetRequest Fleet to be added
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Fleet} and HTTP response
      */
   }, {
     key: "createFleetWithHttpInfo",
-    value: function createFleetWithHttpInfo(projectUID, createFleetRequest) {
+    value: function createFleetWithHttpInfo(projectOrProductUID, createFleetRequest) {
       var postBody = createFleetRequest;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling createFleet");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling createFleet");
       }
       // verify the required parameter 'createFleetRequest' is set
       if (createFleetRequest === undefined || createFleetRequest === null) {
         throw new _Error["default"]("Missing the required parameter 'createFleetRequest' when calling createFleet");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -137,43 +137,43 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = ['application/json'];
       var accepts = ['application/json'];
       var returnType = _Fleet["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/fleets', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/fleets', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Create Fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {module:model/CreateFleetRequest} createFleetRequest Fleet to be added
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Fleet}
      */
   }, {
     key: "createFleet",
-    value: function createFleet(projectUID, createFleetRequest) {
-      return this.createFleetWithHttpInfo(projectUID, createFleetRequest).then(function (response_and_data) {
+    value: function createFleet(projectOrProductUID, createFleetRequest) {
+      return this.createFleetWithHttpInfo(projectOrProductUID, createFleetRequest).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Create Product within a Project
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {module:model/CreateProductRequest} createProductRequest Product to be created
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Product} and HTTP response
      */
   }, {
     key: "createProductWithHttpInfo",
-    value: function createProductWithHttpInfo(projectUID, createProductRequest) {
+    value: function createProductWithHttpInfo(projectOrProductUID, createProductRequest) {
       var postBody = createProductRequest;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling createProduct");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling createProduct");
       }
       // verify the required parameter 'createProductRequest' is set
       if (createProductRequest === undefined || createProductRequest === null) {
         throw new _Error["default"]("Missing the required parameter 'createProductRequest' when calling createProduct");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -182,19 +182,19 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = ['application/json'];
       var accepts = ['application/json'];
       var returnType = _Product["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/products', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/products', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Create Product within a Project
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {module:model/CreateProductRequest} createProductRequest Product to be created
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Product}
      */
   }, {
     key: "createProduct",
-    value: function createProduct(projectUID, createProductRequest) {
-      return this.createProductWithHttpInfo(projectUID, createProductRequest).then(function (response_and_data) {
+    value: function createProduct(projectOrProductUID, createProductRequest) {
+      return this.createProductWithHttpInfo(projectOrProductUID, createProductRequest).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -238,18 +238,18 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Remove Device from Fleets
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} deviceUID 
      * @param {module:model/DeleteDeviceFleetsRequest} deleteDeviceFleetsRequest The fleets to remove from the device. Note that the endpoint takes an array of fleetUIDs, to facilitate multi-fleet devices. Multi-fleet is not yet enabled on all SaaS plans - unless it is supported by the SaaS plan of the project, passing more than a single fleetUID in the array is an error. 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetProjectFleets200Response} and HTTP response
      */
   }, {
     key: "deleteDeviceFleetsWithHttpInfo",
-    value: function deleteDeviceFleetsWithHttpInfo(projectUID, deviceUID, deleteDeviceFleetsRequest) {
+    value: function deleteDeviceFleetsWithHttpInfo(projectOrProductUID, deviceUID, deleteDeviceFleetsRequest) {
       var postBody = deleteDeviceFleetsRequest;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling deleteDeviceFleets");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling deleteDeviceFleets");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -260,7 +260,7 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'deleteDeviceFleetsRequest' when calling deleteDeviceFleets");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -270,44 +270,44 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = ['application/json'];
       var accepts = ['application/json'];
       var returnType = _GetProjectFleets200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/fleets', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/fleets', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Remove Device from Fleets
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} deviceUID 
      * @param {module:model/DeleteDeviceFleetsRequest} deleteDeviceFleetsRequest The fleets to remove from the device. Note that the endpoint takes an array of fleetUIDs, to facilitate multi-fleet devices. Multi-fleet is not yet enabled on all SaaS plans - unless it is supported by the SaaS plan of the project, passing more than a single fleetUID in the array is an error. 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetProjectFleets200Response}
      */
   }, {
     key: "deleteDeviceFleets",
-    value: function deleteDeviceFleets(projectUID, deviceUID, deleteDeviceFleetsRequest) {
-      return this.deleteDeviceFleetsWithHttpInfo(projectUID, deviceUID, deleteDeviceFleetsRequest).then(function (response_and_data) {
+    value: function deleteDeviceFleets(projectOrProductUID, deviceUID, deleteDeviceFleetsRequest) {
+      return this.deleteDeviceFleetsWithHttpInfo(projectOrProductUID, deviceUID, deleteDeviceFleetsRequest).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Delete Fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} fleetUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
     key: "deleteFleetWithHttpInfo",
-    value: function deleteFleetWithHttpInfo(projectUID, fleetUID) {
+    value: function deleteFleetWithHttpInfo(projectOrProductUID, fleetUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling deleteFleet");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling deleteFleet");
       }
       // verify the required parameter 'fleetUID' is set
       if (fleetUID === undefined || fleetUID === null) {
         throw new _Error["default"]("Missing the required parameter 'fleetUID' when calling deleteFleet");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'fleetUID': fleetUID
       };
       var queryParams = {};
@@ -317,37 +317,37 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectUID}/fleets/{fleetUID}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/fleets/{fleetUID}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Delete Fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} fleetUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
     key: "deleteFleet",
-    value: function deleteFleet(projectUID, fleetUID) {
-      return this.deleteFleetWithHttpInfo(projectUID, fleetUID).then(function (response_and_data) {
+    value: function deleteFleet(projectOrProductUID, fleetUID) {
+      return this.deleteFleetWithHttpInfo(projectOrProductUID, fleetUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Delete environment variables of a fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} fleetUID 
      * @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
      */
   }, {
     key: "deleteFleetEnvironmentVariableWithHttpInfo",
-    value: function deleteFleetEnvironmentVariableWithHttpInfo(projectUID, fleetUID, key) {
+    value: function deleteFleetEnvironmentVariableWithHttpInfo(projectOrProductUID, fleetUID, key) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling deleteFleetEnvironmentVariable");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling deleteFleetEnvironmentVariable");
       }
       // verify the required parameter 'fleetUID' is set
       if (fleetUID === undefined || fleetUID === null) {
@@ -358,7 +358,7 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'key' when calling deleteFleetEnvironmentVariable");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'fleetUID': fleetUID,
         'key': key
       };
@@ -369,39 +369,39 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _EnvironmentVariables["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/fleets/{fleetUID}/environment_variables/{key}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/fleets/{fleetUID}/environment_variables/{key}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Delete environment variables of a fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} fleetUID 
      * @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: "deleteFleetEnvironmentVariable",
-    value: function deleteFleetEnvironmentVariable(projectUID, fleetUID, key) {
-      return this.deleteFleetEnvironmentVariableWithHttpInfo(projectUID, fleetUID, key).then(function (response_and_data) {
+    value: function deleteFleetEnvironmentVariable(projectOrProductUID, fleetUID, key) {
+      return this.deleteFleetEnvironmentVariableWithHttpInfo(projectOrProductUID, fleetUID, key).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Delete a Project by ProjectUID
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
     key: "deleteProjectWithHttpInfo",
-    value: function deleteProjectWithHttpInfo(projectUID) {
+    value: function deleteProjectWithHttpInfo(projectOrProductUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling deleteProject");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling deleteProject");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -415,37 +415,37 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Delete a Project by ProjectUID
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
     key: "deleteProject",
-    value: function deleteProject(projectUID) {
-      return this.deleteProjectWithHttpInfo(projectUID).then(function (response_and_data) {
+    value: function deleteProject(projectOrProductUID) {
+      return this.deleteProjectWithHttpInfo(projectOrProductUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Delete an environment variable of a project by key
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @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
      */
   }, {
     key: "deleteProjectEnvironmentVariableWithHttpInfo",
-    value: function deleteProjectEnvironmentVariableWithHttpInfo(projectUID, key) {
+    value: function deleteProjectEnvironmentVariableWithHttpInfo(projectOrProductUID, key) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling deleteProjectEnvironmentVariable");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling deleteProjectEnvironmentVariable");
       }
       // verify the required parameter 'key' is set
       if (key === undefined || key === null) {
         throw new _Error["default"]("Missing the required parameter 'key' when calling deleteProjectEnvironmentVariable");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'key': key
       };
       var queryParams = {};
@@ -455,26 +455,26 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _EnvironmentVariables["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/environment_variables/{key}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/environment_variables/{key}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Delete an environment variable of a project by key
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @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: "deleteProjectEnvironmentVariable",
-    value: function deleteProjectEnvironmentVariable(projectUID, key) {
-      return this.deleteProjectEnvironmentVariableWithHttpInfo(projectUID, key).then(function (response_and_data) {
+    value: function deleteProjectEnvironmentVariable(projectOrProductUID, key) {
+      return this.deleteProjectEnvironmentVariableWithHttpInfo(projectOrProductUID, key).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Update/cancel host or notecard firmware updates
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {module:model/String} firmwareType 
      * @param {module:model/String} action 
      * @param {Object} opts Optional parameters
@@ -492,12 +492,12 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "dfuActionWithHttpInfo",
-    value: function dfuActionWithHttpInfo(projectUID, firmwareType, action, opts) {
+    value: function dfuActionWithHttpInfo(projectOrProductUID, firmwareType, action, opts) {
       opts = opts || {};
       var postBody = opts['dfuActionRequest'];
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling dfuAction");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling dfuAction");
       }
       // verify the required parameter 'firmwareType' is set
       if (firmwareType === undefined || firmwareType === null) {
@@ -508,7 +508,7 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'action' when calling dfuAction");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'firmwareType': firmwareType,
         'action': action
       };
@@ -529,12 +529,12 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = ['application/json'];
       var accepts = ['application/json'];
       var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectUID}/dfu/{firmwareType}/{action}', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/dfu/{firmwareType}/{action}', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Update/cancel host or notecard firmware updates
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {module:model/String} firmwareType 
      * @param {module:model/String} action 
      * @param {Object} opts Optional parameters
@@ -552,27 +552,27 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "dfuAction",
-    value: function dfuAction(projectUID, firmwareType, action, opts) {
-      return this.dfuActionWithHttpInfo(projectUID, firmwareType, action, opts).then(function (response_and_data) {
+    value: function dfuAction(projectOrProductUID, firmwareType, action, opts) {
+      return this.dfuActionWithHttpInfo(projectOrProductUID, firmwareType, action, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Disable the project-level event JSONata transformation
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
     key: "disableGlobalTransformationWithHttpInfo",
-    value: function disableGlobalTransformationWithHttpInfo(projectUID) {
+    value: function disableGlobalTransformationWithHttpInfo(projectOrProductUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling disableGlobalTransformation");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling disableGlobalTransformation");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -581,37 +581,37 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectUID}/global-transformation/disable', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/global-transformation/disable', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Disable the project-level event JSONata transformation
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
     key: "disableGlobalTransformation",
-    value: function disableGlobalTransformation(projectUID) {
-      return this.disableGlobalTransformationWithHttpInfo(projectUID).then(function (response_and_data) {
+    value: function disableGlobalTransformation(projectOrProductUID) {
+      return this.disableGlobalTransformationWithHttpInfo(projectOrProductUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Enable the project-level event JSONata transformation
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
     key: "enableGlobalTransformationWithHttpInfo",
-    value: function enableGlobalTransformationWithHttpInfo(projectUID) {
+    value: function enableGlobalTransformationWithHttpInfo(projectOrProductUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling enableGlobalTransformation");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling enableGlobalTransformation");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -620,36 +620,36 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectUID}/global-transformation/enable', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/global-transformation/enable', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Enable the project-level event JSONata transformation
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
     key: "enableGlobalTransformation",
-    value: function enableGlobalTransformation(projectUID) {
-      return this.enableGlobalTransformationWithHttpInfo(projectUID).then(function (response_and_data) {
+    value: function enableGlobalTransformation(projectOrProductUID) {
+      return this.enableGlobalTransformationWithHttpInfo(projectOrProductUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get device DFU history for host or Notecard firmware
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} deviceUID 
      * @param {module:model/String} firmwareType 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/DeviceDfuHistory} and HTTP response
      */
   }, {
     key: "getDeviceDfuHistoryWithHttpInfo",
-    value: function getDeviceDfuHistoryWithHttpInfo(projectUID, deviceUID, firmwareType) {
+    value: function getDeviceDfuHistoryWithHttpInfo(projectOrProductUID, deviceUID, firmwareType) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getDeviceDfuHistory");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceDfuHistory");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -660,7 +660,7 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'firmwareType' when calling getDeviceDfuHistory");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'deviceUID': deviceUID,
         'firmwareType': firmwareType
       };
@@ -671,38 +671,38 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _DeviceDfuHistory["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/dfu/{firmwareType}/history', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/dfu/{firmwareType}/history', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get device DFU history for host or Notecard firmware
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} deviceUID 
      * @param {module:model/String} firmwareType 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/DeviceDfuHistory}
      */
   }, {
     key: "getDeviceDfuHistory",
-    value: function getDeviceDfuHistory(projectUID, deviceUID, firmwareType) {
-      return this.getDeviceDfuHistoryWithHttpInfo(projectUID, deviceUID, firmwareType).then(function (response_and_data) {
+    value: function getDeviceDfuHistory(projectOrProductUID, deviceUID, firmwareType) {
+      return this.getDeviceDfuHistoryWithHttpInfo(projectOrProductUID, deviceUID, firmwareType).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get device DFU history for host or Notecard firmware
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} deviceUID 
      * @param {module:model/String} firmwareType 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/DeviceDfuStatus} and HTTP response
      */
   }, {
     key: "getDeviceDfuStatusWithHttpInfo",
-    value: function getDeviceDfuStatusWithHttpInfo(projectUID, deviceUID, firmwareType) {
+    value: function getDeviceDfuStatusWithHttpInfo(projectOrProductUID, deviceUID, firmwareType) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getDeviceDfuStatus");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceDfuStatus");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -713,7 +713,7 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'firmwareType' when calling getDeviceDfuStatus");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'deviceUID': deviceUID,
         'firmwareType': firmwareType
       };
@@ -724,44 +724,44 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _DeviceDfuStatus["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/dfu/{firmwareType}/status', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/dfu/{firmwareType}/status', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get device DFU history for host or Notecard firmware
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} deviceUID 
      * @param {module:model/String} firmwareType 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/DeviceDfuStatus}
      */
   }, {
     key: "getDeviceDfuStatus",
-    value: function getDeviceDfuStatus(projectUID, deviceUID, firmwareType) {
-      return this.getDeviceDfuStatusWithHttpInfo(projectUID, deviceUID, firmwareType).then(function (response_and_data) {
+    value: function getDeviceDfuStatus(projectOrProductUID, deviceUID, firmwareType) {
+      return this.getDeviceDfuStatusWithHttpInfo(projectOrProductUID, deviceUID, firmwareType).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Device Fleets
-     * @param {String} projectUID 
+     * @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/GetProjectFleets200Response} and HTTP response
      */
   }, {
     key: "getDeviceFleetsWithHttpInfo",
-    value: function getDeviceFleetsWithHttpInfo(projectUID, deviceUID) {
+    value: function getDeviceFleetsWithHttpInfo(projectOrProductUID, deviceUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getDeviceFleets");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDeviceFleets");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
         throw new _Error["default"]("Missing the required parameter 'deviceUID' when calling getDeviceFleets");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -771,26 +771,26 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _GetProjectFleets200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/fleets', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/fleets', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Device Fleets
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} deviceUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetProjectFleets200Response}
      */
   }, {
     key: "getDeviceFleets",
-    value: function getDeviceFleets(projectUID, deviceUID) {
-      return this.getDeviceFleetsWithHttpInfo(projectUID, deviceUID).then(function (response_and_data) {
+    value: function getDeviceFleets(projectOrProductUID, deviceUID) {
+      return this.getDeviceFleetsWithHttpInfo(projectOrProductUID, deviceUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get host or Notecard DFU history for all devices that match the filter criteria
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {module:model/String} firmwareType 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.pageSize  (default to 50)
@@ -810,19 +810,19 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getDevicesDfuHistoryWithHttpInfo",
-    value: function getDevicesDfuHistoryWithHttpInfo(projectUID, firmwareType, opts) {
+    value: function getDevicesDfuHistoryWithHttpInfo(projectOrProductUID, firmwareType, opts) {
       opts = opts || {};
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getDevicesDfuHistory");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDevicesDfuHistory");
       }
       // verify the required parameter 'firmwareType' is set
       if (firmwareType === undefined || firmwareType === null) {
         throw new _Error["default"]("Missing the required parameter 'firmwareType' when calling getDevicesDfuHistory");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'firmwareType': firmwareType
       };
       var queryParams = {
@@ -846,12 +846,12 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _DeviceDfuHistoryPage["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/dfu/{firmwareType}/history', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/dfu/{firmwareType}/history', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get host or Notecard DFU history for all devices that match the filter criteria
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {module:model/String} firmwareType 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.pageSize  (default to 50)
@@ -871,15 +871,15 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getDevicesDfuHistory",
-    value: function getDevicesDfuHistory(projectUID, firmwareType, opts) {
-      return this.getDevicesDfuHistoryWithHttpInfo(projectUID, firmwareType, opts).then(function (response_and_data) {
+    value: function getDevicesDfuHistory(projectOrProductUID, firmwareType, opts) {
+      return this.getDevicesDfuHistoryWithHttpInfo(projectOrProductUID, firmwareType, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get host or Notecard DFU history for all devices that match the filter criteria
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {module:model/String} firmwareType 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.pageSize  (default to 50)
@@ -899,19 +899,19 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getDevicesDfuStatusWithHttpInfo",
-    value: function getDevicesDfuStatusWithHttpInfo(projectUID, firmwareType, opts) {
+    value: function getDevicesDfuStatusWithHttpInfo(projectOrProductUID, firmwareType, opts) {
       opts = opts || {};
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getDevicesDfuStatus");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getDevicesDfuStatus");
       }
       // verify the required parameter 'firmwareType' is set
       if (firmwareType === undefined || firmwareType === null) {
         throw new _Error["default"]("Missing the required parameter 'firmwareType' when calling getDevicesDfuStatus");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'firmwareType': firmwareType
       };
       var queryParams = {
@@ -935,12 +935,12 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _DeviceDfuStatusPage["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/dfu/{firmwareType}/status', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/dfu/{firmwareType}/status', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get host or Notecard DFU history for all devices that match the filter criteria
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {module:model/String} firmwareType 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.pageSize  (default to 50)
@@ -960,15 +960,15 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getDevicesDfuStatus",
-    value: function getDevicesDfuStatus(projectUID, firmwareType, opts) {
-      return this.getDevicesDfuStatusWithHttpInfo(projectUID, firmwareType, opts).then(function (response_and_data) {
+    value: function getDevicesDfuStatus(projectOrProductUID, firmwareType, opts) {
+      return this.getDevicesDfuStatusWithHttpInfo(projectOrProductUID, firmwareType, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Available Firmware Information
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {Object} opts Optional parameters
      * @param {String} opts.product 
      * @param {String} opts.firmwareType 
@@ -981,15 +981,15 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getFirmwareInfoWithHttpInfo",
-    value: function getFirmwareInfoWithHttpInfo(projectUID, opts) {
+    value: function getFirmwareInfoWithHttpInfo(projectOrProductUID, opts) {
       opts = opts || {};
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getFirmwareInfo");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getFirmwareInfo");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {
         'product': opts['product'],
@@ -1006,12 +1006,12 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = [_FirmwareInfo["default"]];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/firmware', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/firmware', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Available Firmware Information
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {Object} opts Optional parameters
      * @param {String} opts.product 
      * @param {String} opts.firmwareType 
@@ -1024,32 +1024,32 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "getFirmwareInfo",
-    value: function getFirmwareInfo(projectUID, opts) {
-      return this.getFirmwareInfoWithHttpInfo(projectUID, opts).then(function (response_and_data) {
+    value: function getFirmwareInfo(projectOrProductUID, opts) {
+      return this.getFirmwareInfoWithHttpInfo(projectOrProductUID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} fleetUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Fleet} and HTTP response
      */
   }, {
     key: "getFleetWithHttpInfo",
-    value: function getFleetWithHttpInfo(projectUID, fleetUID) {
+    value: function getFleetWithHttpInfo(projectOrProductUID, fleetUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getFleet");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getFleet");
       }
       // verify the required parameter 'fleetUID' is set
       if (fleetUID === undefined || fleetUID === null) {
         throw new _Error["default"]("Missing the required parameter 'fleetUID' when calling getFleet");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'fleetUID': fleetUID
       };
       var queryParams = {};
@@ -1059,43 +1059,43 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _Fleet["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/fleets/{fleetUID}', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/fleets/{fleetUID}', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} fleetUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Fleet}
      */
   }, {
     key: "getFleet",
-    value: function getFleet(projectUID, fleetUID) {
-      return this.getFleetWithHttpInfo(projectUID, fleetUID).then(function (response_and_data) {
+    value: function getFleet(projectOrProductUID, fleetUID) {
+      return this.getFleetWithHttpInfo(projectOrProductUID, fleetUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get environment variables of a fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} fleetUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EnvironmentVariables} and HTTP response
      */
   }, {
     key: "getFleetEnvironmentVariablesWithHttpInfo",
-    value: function getFleetEnvironmentVariablesWithHttpInfo(projectUID, fleetUID) {
+    value: function getFleetEnvironmentVariablesWithHttpInfo(projectOrProductUID, fleetUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getFleetEnvironmentVariables");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getFleetEnvironmentVariables");
       }
       // verify the required parameter 'fleetUID' is set
       if (fleetUID === undefined || fleetUID === null) {
         throw new _Error["default"]("Missing the required parameter 'fleetUID' when calling getFleetEnvironmentVariables");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'fleetUID': fleetUID
       };
       var queryParams = {};
@@ -1105,38 +1105,38 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _EnvironmentVariables["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/fleets/{fleetUID}/environment_variables', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/fleets/{fleetUID}/environment_variables', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get environment variables of a fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} fleetUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EnvironmentVariables}
      */
   }, {
     key: "getFleetEnvironmentVariables",
-    value: function getFleetEnvironmentVariables(projectUID, fleetUID) {
-      return this.getFleetEnvironmentVariablesWithHttpInfo(projectUID, fleetUID).then(function (response_and_data) {
+    value: function getFleetEnvironmentVariables(projectOrProductUID, fleetUID) {
+      return this.getFleetEnvironmentVariablesWithHttpInfo(projectOrProductUID, fleetUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get variable format for a notefile
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link Array.<module:model/NotefileSchema>} and HTTP response
      */
   }, {
     key: "getNotefileSchemasWithHttpInfo",
-    value: function getNotefileSchemasWithHttpInfo(projectUID) {
+    value: function getNotefileSchemasWithHttpInfo(projectOrProductUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getNotefileSchemas");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getNotefileSchemas");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -1145,37 +1145,37 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = [_NotefileSchema["default"]];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/schemas', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/schemas', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get variable format for a notefile
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link Array.<module:model/NotefileSchema>}
      */
   }, {
     key: "getNotefileSchemas",
-    value: function getNotefileSchemas(projectUID) {
-      return this.getNotefileSchemasWithHttpInfo(projectUID).then(function (response_and_data) {
+    value: function getNotefileSchemas(projectOrProductUID) {
+      return this.getNotefileSchemasWithHttpInfo(projectOrProductUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get a Project by ProjectUID
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Project} and HTTP response
      */
   }, {
     key: "getProjectWithHttpInfo",
-    value: function getProjectWithHttpInfo(projectUID) {
+    value: function getProjectWithHttpInfo(projectOrProductUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getProject");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getProject");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -1189,13 +1189,13 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Get a Project by ProjectUID
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Project}
      */
   }, {
     key: "getProject",
-    value: function getProject(projectUID) {
-      return this.getProjectWithHttpInfo(projectUID).then(function (response_and_data) {
+    value: function getProject(projectOrProductUID) {
+      return this.getProjectWithHttpInfo(projectOrProductUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -1241,19 +1241,19 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Get environment variables of a project
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EnvironmentVariables} and HTTP response
      */
   }, {
     key: "getProjectEnvironmentVariablesWithHttpInfo",
-    value: function getProjectEnvironmentVariablesWithHttpInfo(projectUID) {
+    value: function getProjectEnvironmentVariablesWithHttpInfo(projectOrProductUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getProjectEnvironmentVariables");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getProjectEnvironmentVariables");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -1262,37 +1262,37 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _EnvironmentVariables["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/environment_variables', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/environment_variables', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get environment variables of a project
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EnvironmentVariables}
      */
   }, {
     key: "getProjectEnvironmentVariables",
-    value: function getProjectEnvironmentVariables(projectUID) {
-      return this.getProjectEnvironmentVariablesWithHttpInfo(projectUID).then(function (response_and_data) {
+    value: function getProjectEnvironmentVariables(projectOrProductUID) {
+      return this.getProjectEnvironmentVariablesWithHttpInfo(projectOrProductUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Project Fleets
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetProjectFleets200Response} and HTTP response
      */
   }, {
     key: "getProjectFleetsWithHttpInfo",
-    value: function getProjectFleetsWithHttpInfo(projectUID) {
+    value: function getProjectFleetsWithHttpInfo(projectOrProductUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getProjectFleets");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getProjectFleets");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -1301,37 +1301,37 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _GetProjectFleets200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/fleets', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/fleets', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Project Fleets
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetProjectFleets200Response}
      */
   }, {
     key: "getProjectFleets",
-    value: function getProjectFleets(projectUID) {
-      return this.getProjectFleetsWithHttpInfo(projectUID).then(function (response_and_data) {
+    value: function getProjectFleets(projectOrProductUID) {
+      return this.getProjectFleetsWithHttpInfo(projectOrProductUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Project Members
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetProjectMembers200Response} and HTTP response
      */
   }, {
     key: "getProjectMembersWithHttpInfo",
-    value: function getProjectMembersWithHttpInfo(projectUID) {
+    value: function getProjectMembersWithHttpInfo(projectOrProductUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getProjectMembers");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getProjectMembers");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -1340,37 +1340,37 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _GetProjectMembers200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/members', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/members', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Project Members
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetProjectMembers200Response}
      */
   }, {
     key: "getProjectMembers",
-    value: function getProjectMembers(projectUID) {
-      return this.getProjectMembersWithHttpInfo(projectUID).then(function (response_and_data) {
+    value: function getProjectMembers(projectOrProductUID) {
+      return this.getProjectMembersWithHttpInfo(projectOrProductUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Get Products within a Project
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetProjectProducts200Response} and HTTP response
      */
   }, {
     key: "getProjectProductsWithHttpInfo",
-    value: function getProjectProductsWithHttpInfo(projectUID) {
+    value: function getProjectProductsWithHttpInfo(projectOrProductUID) {
       var postBody = null;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling getProjectProducts");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling getProjectProducts");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -1379,18 +1379,18 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = [];
       var accepts = ['application/json'];
       var returnType = _GetProjectProducts200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/products', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/products', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Get Products within a Project
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetProjectProducts200Response}
      */
   }, {
     key: "getProjectProducts",
-    value: function getProjectProducts(projectUID) {
-      return this.getProjectProductsWithHttpInfo(projectUID).then(function (response_and_data) {
+    value: function getProjectProducts(projectOrProductUID) {
+      return this.getProjectProductsWithHttpInfo(projectOrProductUID).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -1428,18 +1428,18 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Add Device to Fleets
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} deviceUID 
      * @param {module:model/PutDeviceFleetsRequest} putDeviceFleetsRequest The fleets to add to the device. Note that the endpoint takes an array of fleetUIDs, to facilitate multi-fleet devices. Multi-fleet is not yet enabled on all SaaS plans - unless it is supported by the SaaS plan of the project, passing more than a single fleetUID in the array is an error. 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/GetProjectFleets200Response} and HTTP response
      */
   }, {
     key: "putDeviceFleetsWithHttpInfo",
-    value: function putDeviceFleetsWithHttpInfo(projectUID, deviceUID, putDeviceFleetsRequest) {
+    value: function putDeviceFleetsWithHttpInfo(projectOrProductUID, deviceUID, putDeviceFleetsRequest) {
       var postBody = putDeviceFleetsRequest;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling putDeviceFleets");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling putDeviceFleets");
       }
       // verify the required parameter 'deviceUID' is set
       if (deviceUID === undefined || deviceUID === null) {
@@ -1450,7 +1450,7 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'putDeviceFleetsRequest' when calling putDeviceFleets");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'deviceUID': deviceUID
       };
       var queryParams = {};
@@ -1460,38 +1460,38 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = ['application/json'];
       var accepts = ['application/json'];
       var returnType = _GetProjectFleets200Response["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/devices/{deviceUID}/fleets', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/devices/{deviceUID}/fleets', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Add Device to Fleets
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} deviceUID 
      * @param {module:model/PutDeviceFleetsRequest} putDeviceFleetsRequest The fleets to add to the device. Note that the endpoint takes an array of fleetUIDs, to facilitate multi-fleet devices. Multi-fleet is not yet enabled on all SaaS plans - unless it is supported by the SaaS plan of the project, passing more than a single fleetUID in the array is an error. 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/GetProjectFleets200Response}
      */
   }, {
     key: "putDeviceFleets",
-    value: function putDeviceFleets(projectUID, deviceUID, putDeviceFleetsRequest) {
-      return this.putDeviceFleetsWithHttpInfo(projectUID, deviceUID, putDeviceFleetsRequest).then(function (response_and_data) {
+    value: function putDeviceFleets(projectOrProductUID, deviceUID, putDeviceFleetsRequest) {
+      return this.putDeviceFleetsWithHttpInfo(projectOrProductUID, deviceUID, putDeviceFleetsRequest).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Put environment variables of a fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} fleetUID 
      * @param {module:model/EnvironmentVariables} environmentVariables Environment variables to be added to the fleet
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EnvironmentVariables} and HTTP response
      */
   }, {
     key: "putFleetEnvironmentVariablesWithHttpInfo",
-    value: function putFleetEnvironmentVariablesWithHttpInfo(projectUID, fleetUID, environmentVariables) {
+    value: function putFleetEnvironmentVariablesWithHttpInfo(projectOrProductUID, fleetUID, environmentVariables) {
       var postBody = environmentVariables;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling putFleetEnvironmentVariables");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling putFleetEnvironmentVariables");
       }
       // verify the required parameter 'fleetUID' is set
       if (fleetUID === undefined || fleetUID === null) {
@@ -1502,7 +1502,7 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'environmentVariables' when calling putFleetEnvironmentVariables");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'fleetUID': fleetUID
       };
       var queryParams = {};
@@ -1512,42 +1512,42 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = ['application/json'];
       var accepts = ['application/json'];
       var returnType = _EnvironmentVariables["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/fleets/{fleetUID}/environment_variables', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/fleets/{fleetUID}/environment_variables', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Put environment variables of a fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} fleetUID 
      * @param {module:model/EnvironmentVariables} environmentVariables Environment variables to be added to the fleet
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EnvironmentVariables}
      */
   }, {
     key: "putFleetEnvironmentVariables",
-    value: function putFleetEnvironmentVariables(projectUID, fleetUID, environmentVariables) {
-      return this.putFleetEnvironmentVariablesWithHttpInfo(projectUID, fleetUID, environmentVariables).then(function (response_and_data) {
+    value: function putFleetEnvironmentVariables(projectOrProductUID, fleetUID, environmentVariables) {
+      return this.putFleetEnvironmentVariablesWithHttpInfo(projectOrProductUID, fleetUID, environmentVariables).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Put environment variables of a project
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {Object} opts Optional parameters
      * @param {module:model/EnvironmentVariables} opts.environmentVariables 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EnvironmentVariables} and HTTP response
      */
   }, {
     key: "putProjectEnvironmentVariablesWithHttpInfo",
-    value: function putProjectEnvironmentVariablesWithHttpInfo(projectUID, opts) {
+    value: function putProjectEnvironmentVariablesWithHttpInfo(projectOrProductUID, opts) {
       opts = opts || {};
       var postBody = opts['environmentVariables'];
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling putProjectEnvironmentVariables");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling putProjectEnvironmentVariables");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -1556,44 +1556,44 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = ['application/json'];
       var accepts = ['application/json'];
       var returnType = _EnvironmentVariables["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/environment_variables', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/environment_variables', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Put environment variables of a project
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {Object} opts Optional parameters
      * @param {module:model/EnvironmentVariables} opts.environmentVariables 
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EnvironmentVariables}
      */
   }, {
     key: "putProjectEnvironmentVariables",
-    value: function putProjectEnvironmentVariables(projectUID, opts) {
-      return this.putProjectEnvironmentVariablesWithHttpInfo(projectUID, opts).then(function (response_and_data) {
+    value: function putProjectEnvironmentVariables(projectOrProductUID, opts) {
+      return this.putProjectEnvironmentVariablesWithHttpInfo(projectOrProductUID, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Set the project-level event JSONata transformation
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {Object.<String, Object>} body JSONata expression which will be applied to each event before it is persisted and routed
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response
      */
   }, {
     key: "setGlobalTransformationWithHttpInfo",
-    value: function setGlobalTransformationWithHttpInfo(projectUID, body) {
+    value: function setGlobalTransformationWithHttpInfo(projectOrProductUID, body) {
       var postBody = body;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling setGlobalTransformation");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling setGlobalTransformation");
       }
       // verify the required parameter 'body' is set
       if (body === undefined || body === null) {
         throw new _Error["default"]("Missing the required parameter 'body' when calling setGlobalTransformation");
       }
       var pathParams = {
-        'projectUID': projectUID
+        'projectOrProductUID': projectOrProductUID
       };
       var queryParams = {};
       var headerParams = {};
@@ -1602,37 +1602,37 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = ['application/json'];
       var accepts = ['application/json'];
       var returnType = null;
-      return this.apiClient.callApi('/v1/projects/{projectUID}/global-transformation', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/global-transformation', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Set the project-level event JSONata transformation
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {Object.<String, Object>} body JSONata expression which will be applied to each event before it is persisted and routed
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}
      */
   }, {
     key: "setGlobalTransformation",
-    value: function setGlobalTransformation(projectUID, body) {
-      return this.setGlobalTransformationWithHttpInfo(projectUID, body).then(function (response_and_data) {
+    value: function setGlobalTransformation(projectOrProductUID, body) {
+      return this.setGlobalTransformationWithHttpInfo(projectOrProductUID, body).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Update Fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} fleetUID 
      * @param {module:model/UpdateFleetRequest} updateFleetRequest Fleet details to update
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Fleet} and HTTP response
      */
   }, {
     key: "updateFleetWithHttpInfo",
-    value: function updateFleetWithHttpInfo(projectUID, fleetUID, updateFleetRequest) {
+    value: function updateFleetWithHttpInfo(projectOrProductUID, fleetUID, updateFleetRequest) {
       var postBody = updateFleetRequest;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling updateFleet");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling updateFleet");
       }
       // verify the required parameter 'fleetUID' is set
       if (fleetUID === undefined || fleetUID === null) {
@@ -1643,7 +1643,7 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'updateFleetRequest' when calling updateFleet");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'fleetUID': fleetUID
       };
       var queryParams = {};
@@ -1653,27 +1653,27 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = ['application/json'];
       var accepts = ['application/json'];
       var returnType = _Fleet["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/fleets/{fleetUID}', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/fleets/{fleetUID}', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Update Fleet
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {String} fleetUID 
      * @param {module:model/UpdateFleetRequest} updateFleetRequest Fleet details to update
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Fleet}
      */
   }, {
     key: "updateFleet",
-    value: function updateFleet(projectUID, fleetUID, updateFleetRequest) {
-      return this.updateFleetWithHttpInfo(projectUID, fleetUID, updateFleetRequest).then(function (response_and_data) {
+    value: function updateFleet(projectOrProductUID, fleetUID, updateFleetRequest) {
+      return this.updateFleetWithHttpInfo(projectOrProductUID, fleetUID, updateFleetRequest).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Upload firmware binary
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {module:model/String} firmwareType 
      * @param {String} filename 
      * @param {File} body contents of the firmware binary
@@ -1681,11 +1681,11 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "uploadFirmwareWithHttpInfo",
-    value: function uploadFirmwareWithHttpInfo(projectUID, firmwareType, filename, body) {
+    value: function uploadFirmwareWithHttpInfo(projectOrProductUID, firmwareType, filename, body) {
       var postBody = body;
-      // verify the required parameter 'projectUID' is set
-      if (projectUID === undefined || projectUID === null) {
-        throw new _Error["default"]("Missing the required parameter 'projectUID' when calling uploadFirmware");
+      // verify the required parameter 'projectOrProductUID' is set
+      if (projectOrProductUID === undefined || projectOrProductUID === null) {
+        throw new _Error["default"]("Missing the required parameter 'projectOrProductUID' when calling uploadFirmware");
       }
       // verify the required parameter 'firmwareType' is set
       if (firmwareType === undefined || firmwareType === null) {
@@ -1700,7 +1700,7 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
         throw new _Error["default"]("Missing the required parameter 'body' when calling uploadFirmware");
       }
       var pathParams = {
-        'projectUID': projectUID,
+        'projectOrProductUID': projectOrProductUID,
         'firmwareType': firmwareType,
         'filename': filename
       };
@@ -1711,12 +1711,12 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
       var contentTypes = ['application/octet-stream'];
       var accepts = ['application/json'];
       var returnType = _FirmwareInfo["default"];
-      return this.apiClient.callApi('/v1/projects/{projectUID}/firmware/{firmwareType}/{filename}', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      return this.apiClient.callApi('/v1/projects/{projectOrProductUID}/firmware/{firmwareType}/{filename}', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
      * Upload firmware binary
-     * @param {String} projectUID 
+     * @param {String} projectOrProductUID 
      * @param {module:model/String} firmwareType 
      * @param {String} filename 
      * @param {File} body contents of the firmware binary
@@ -1724,8 +1724,8 @@ var ProjectApi = exports["default"] = /*#__PURE__*/function () {
      */
   }, {
     key: "uploadFirmware",
-    value: function uploadFirmware(projectUID, firmwareType, filename, body) {
-      return this.uploadFirmwareWithHttpInfo(projectUID, firmwareType, filename, body).then(function (response_and_data) {
+    value: function uploadFirmware(projectOrProductUID, firmwareType, filename, body) {
+      return this.uploadFirmwareWithHttpInfo(projectOrProductUID, firmwareType, filename, body).then(function (response_and_data) {
         return response_and_data.data;
       });
     }