@ricado/api-client 2.3.11 → 2.3.14

package/lib/Controllers/Packhouse/ProductionDataExportController.js

@@ -0,0 +1,4110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _RequestHelper = _interopRequireDefault(require("../../RequestHelper"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+/**
+ * The Production Data Export Controller Class
+ * 
+ * @class
+ */
+var ProductionDataExportController = /*#__PURE__*/function () {
+  function ProductionDataExportController() {
+    _classCallCheck(this, ProductionDataExportController);
+  }
+
+  _createClass(ProductionDataExportController, null, [{
+    key: "jsonExport",
+    value:
+    /**
+     * Retrieve Production Data [GET /packhouse/production-data-export]
+     * 
+     * Request a Production Data Export in the default JSON Format
+     * 
+     * @static
+     * @public
+     * @param {Date} dateBegin The Beginning Date of the Production Data Export
+     * @param {Date} dateEnd The End Date of the Production Data Export
+     * @param {ProductionDataExportController.JsonExportQueryParameters} [queryParameters] The Optional Query Parameters
+     * @return {Promise<ProductionDataExportController.ProductionData>}
+     */
+    function jsonExport(dateBegin, dateEnd) {
+      var queryParameters = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      return new Promise(function (resolve, reject) {
+        _RequestHelper.default.getRequest("/packhouse/production-data-export", Object.assign(queryParameters, {
+          dateBegin: dateBegin,
+          dateEnd: dateEnd
+        })).then(function (result) {
+          var resolveValue = function () {
+            var resultObject = {};
+
+            if (_typeof(result) === 'object' && 'packruns' in result) {
+              resultObject.packruns = function () {
+                if (Array.isArray(result.packruns) !== true) {
+                  return [];
+                }
+
+                return result.packruns.map(function (packrunsItem) {
+                  return function () {
+                    var packrunsItemObject = {};
+
+                    if (_typeof(packrunsItem) === 'object' && 'siteId' in packrunsItem) {
+                      packrunsItemObject.siteId = function () {
+                        if (typeof packrunsItem.siteId !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.siteId)) ? Number(packrunsItem.siteId) : Math.floor(Number(packrunsItem.siteId));
+                        }
+
+                        return Number.isInteger(packrunsItem.siteId) ? packrunsItem.siteId : Math.floor(packrunsItem.siteId);
+                      }();
+                    } else {
+                      packrunsItemObject.siteId = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'siteName' in packrunsItem) {
+                      packrunsItemObject.siteName = function () {
+                        if (typeof packrunsItem.siteName !== 'string') {
+                          return String(packrunsItem.siteName);
+                        }
+
+                        return packrunsItem.siteName;
+                      }();
+                    } else {
+                      packrunsItemObject.siteName = "";
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'packingLineId' in packrunsItem) {
+                      packrunsItemObject.packingLineId = function () {
+                        if (typeof packrunsItem.packingLineId !== 'string') {
+                          return String(packrunsItem.packingLineId);
+                        }
+
+                        return packrunsItem.packingLineId;
+                      }();
+                    } else {
+                      packrunsItemObject.packingLineId = "";
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'packingLineName' in packrunsItem) {
+                      packrunsItemObject.packingLineName = function () {
+                        if (typeof packrunsItem.packingLineName !== 'string') {
+                          return String(packrunsItem.packingLineName);
+                        }
+
+                        return packrunsItem.packingLineName;
+                      }();
+                    } else {
+                      packrunsItemObject.packingLineName = "";
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'isoWeek' in packrunsItem) {
+                      packrunsItemObject.isoWeek = function () {
+                        if (typeof packrunsItem.isoWeek !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.isoWeek)) ? Number(packrunsItem.isoWeek) : Math.floor(Number(packrunsItem.isoWeek));
+                        }
+
+                        return Number.isInteger(packrunsItem.isoWeek) ? packrunsItem.isoWeek : Math.floor(packrunsItem.isoWeek);
+                      }();
+                    } else {
+                      packrunsItemObject.isoWeek = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'startTimestamp' in packrunsItem) {
+                      packrunsItemObject.startTimestamp = function () {
+                        if (typeof packrunsItem.startTimestamp !== 'string') {
+                          return new Date(String(packrunsItem.startTimestamp));
+                        }
+
+                        return new Date(packrunsItem.startTimestamp);
+                      }();
+                    } else {
+                      packrunsItemObject.startTimestamp = new Date();
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'finishTimestamp' in packrunsItem) {
+                      packrunsItemObject.finishTimestamp = function () {
+                        if (packrunsItem.finishTimestamp === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.finishTimestamp !== 'string') {
+                          return new Date(String(packrunsItem.finishTimestamp));
+                        }
+
+                        return new Date(packrunsItem.finishTimestamp);
+                      }();
+                    } else {
+                      packrunsItemObject.finishTimestamp = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'packrunId' in packrunsItem) {
+                      packrunsItemObject.packrunId = function () {
+                        if (typeof packrunsItem.packrunId !== 'string') {
+                          return String(packrunsItem.packrunId);
+                        }
+
+                        return packrunsItem.packrunId;
+                      }();
+                    } else {
+                      packrunsItemObject.packrunId = "";
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'packrunName' in packrunsItem) {
+                      packrunsItemObject.packrunName = function () {
+                        if (typeof packrunsItem.packrunName !== 'string') {
+                          return String(packrunsItem.packrunName);
+                        }
+
+                        return packrunsItem.packrunName;
+                      }();
+                    } else {
+                      packrunsItemObject.packrunName = "";
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'varietyId' in packrunsItem) {
+                      packrunsItemObject.varietyId = function () {
+                        if (typeof packrunsItem.varietyId !== 'string') {
+                          return String(packrunsItem.varietyId);
+                        }
+
+                        return packrunsItem.varietyId;
+                      }();
+                    } else {
+                      packrunsItemObject.varietyId = "";
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'varietyCode' in packrunsItem) {
+                      packrunsItemObject.varietyCode = function () {
+                        if (typeof packrunsItem.varietyCode !== 'string') {
+                          return String(packrunsItem.varietyCode);
+                        }
+
+                        return packrunsItem.varietyCode;
+                      }();
+                    } else {
+                      packrunsItemObject.varietyCode = "";
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'growingMethodId' in packrunsItem) {
+                      packrunsItemObject.growingMethodId = function () {
+                        if (typeof packrunsItem.growingMethodId !== 'string') {
+                          return String(packrunsItem.growingMethodId);
+                        }
+
+                        return packrunsItem.growingMethodId;
+                      }();
+                    } else {
+                      packrunsItemObject.growingMethodId = "";
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'growingMethodCode' in packrunsItem) {
+                      packrunsItemObject.growingMethodCode = function () {
+                        if (typeof packrunsItem.growingMethodCode !== 'string') {
+                          return String(packrunsItem.growingMethodCode);
+                        }
+
+                        return packrunsItem.growingMethodCode;
+                      }();
+                    } else {
+                      packrunsItemObject.growingMethodCode = "";
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'growerCode' in packrunsItem) {
+                      packrunsItemObject.growerCode = function () {
+                        if (typeof packrunsItem.growerCode !== 'string') {
+                          return String(packrunsItem.growerCode);
+                        }
+
+                        return packrunsItem.growerCode;
+                      }();
+                    } else {
+                      packrunsItemObject.growerCode = "";
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'growerName' in packrunsItem) {
+                      packrunsItemObject.growerName = function () {
+                        if (typeof packrunsItem.growerName !== 'string') {
+                          return String(packrunsItem.growerName);
+                        }
+
+                        return packrunsItem.growerName;
+                      }();
+                    } else {
+                      packrunsItemObject.growerName = "";
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'maturityArea' in packrunsItem) {
+                      packrunsItemObject.maturityArea = function () {
+                        if (typeof packrunsItem.maturityArea !== 'string') {
+                          return String(packrunsItem.maturityArea);
+                        }
+
+                        return packrunsItem.maturityArea;
+                      }();
+                    } else {
+                      packrunsItemObject.maturityArea = "";
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'allocatedBins' in packrunsItem) {
+                      packrunsItemObject.allocatedBins = function () {
+                        if (typeof packrunsItem.allocatedBins !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.allocatedBins)) ? Number(packrunsItem.allocatedBins) : Math.floor(Number(packrunsItem.allocatedBins));
+                        }
+
+                        return Number.isInteger(packrunsItem.allocatedBins) ? packrunsItem.allocatedBins : Math.floor(packrunsItem.allocatedBins);
+                      }();
+                    } else {
+                      packrunsItemObject.allocatedBins = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalBinsTipped' in packrunsItem) {
+                      packrunsItemObject.totalBinsTipped = function () {
+                        if (typeof packrunsItem.totalBinsTipped !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.totalBinsTipped)) ? Number(packrunsItem.totalBinsTipped) : Math.floor(Number(packrunsItem.totalBinsTipped));
+                        }
+
+                        return Number.isInteger(packrunsItem.totalBinsTipped) ? packrunsItem.totalBinsTipped : Math.floor(packrunsItem.totalBinsTipped);
+                      }();
+                    } else {
+                      packrunsItemObject.totalBinsTipped = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalNetWeightTipped' in packrunsItem) {
+                      packrunsItemObject.totalNetWeightTipped = function () {
+                        if (typeof packrunsItem.totalNetWeightTipped !== 'number') {
+                          return Number(packrunsItem.totalNetWeightTipped);
+                        }
+
+                        return packrunsItem.totalNetWeightTipped;
+                      }();
+                    } else {
+                      packrunsItemObject.totalNetWeightTipped = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'averageNetWeightPerBin' in packrunsItem) {
+                      packrunsItemObject.averageNetWeightPerBin = function () {
+                        if (typeof packrunsItem.averageNetWeightPerBin !== 'number') {
+                          return Number(packrunsItem.averageNetWeightPerBin);
+                        }
+
+                        return packrunsItem.averageNetWeightPerBin;
+                      }();
+                    } else {
+                      packrunsItemObject.averageNetWeightPerBin = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'averageBinsTippedPerHour' in packrunsItem) {
+                      packrunsItemObject.averageBinsTippedPerHour = function () {
+                        if (typeof packrunsItem.averageBinsTippedPerHour !== 'number') {
+                          return Number(packrunsItem.averageBinsTippedPerHour);
+                        }
+
+                        return packrunsItem.averageBinsTippedPerHour;
+                      }();
+                    } else {
+                      packrunsItemObject.averageBinsTippedPerHour = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'averageTimePerTippedBin' in packrunsItem) {
+                      packrunsItemObject.averageTimePerTippedBin = function () {
+                        if (typeof packrunsItem.averageTimePerTippedBin !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.averageTimePerTippedBin)) ? Number(packrunsItem.averageTimePerTippedBin) : Math.floor(Number(packrunsItem.averageTimePerTippedBin));
+                        }
+
+                        return Number.isInteger(packrunsItem.averageTimePerTippedBin) ? packrunsItem.averageTimePerTippedBin : Math.floor(packrunsItem.averageTimePerTippedBin);
+                      }();
+                    } else {
+                      packrunsItemObject.averageTimePerTippedBin = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'averageBinTipWeightThroughput' in packrunsItem) {
+                      packrunsItemObject.averageBinTipWeightThroughput = function () {
+                        if (typeof packrunsItem.averageBinTipWeightThroughput !== 'number') {
+                          return Number(packrunsItem.averageBinTipWeightThroughput);
+                        }
+
+                        return packrunsItem.averageBinTipWeightThroughput;
+                      }();
+                    } else {
+                      packrunsItemObject.averageBinTipWeightThroughput = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'softSortEventsPerBin' in packrunsItem) {
+                      packrunsItemObject.softSortEventsPerBin = function () {
+                        if (typeof packrunsItem.softSortEventsPerBin !== 'number') {
+                          return Number(packrunsItem.softSortEventsPerBin);
+                        }
+
+                        return packrunsItem.softSortEventsPerBin;
+                      }();
+                    } else {
+                      packrunsItemObject.softSortEventsPerBin = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalSoftSortEventsCount' in packrunsItem) {
+                      packrunsItemObject.totalSoftSortEventsCount = function () {
+                        if (typeof packrunsItem.totalSoftSortEventsCount !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.totalSoftSortEventsCount)) ? Number(packrunsItem.totalSoftSortEventsCount) : Math.floor(Number(packrunsItem.totalSoftSortEventsCount));
+                        }
+
+                        return Number.isInteger(packrunsItem.totalSoftSortEventsCount) ? packrunsItem.totalSoftSortEventsCount : Math.floor(packrunsItem.totalSoftSortEventsCount);
+                      }();
+                    } else {
+                      packrunsItemObject.totalSoftSortEventsCount = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'averageSoftSortEventsDuration' in packrunsItem) {
+                      packrunsItemObject.averageSoftSortEventsDuration = function () {
+                        if (typeof packrunsItem.averageSoftSortEventsDuration !== 'number') {
+                          return Number(packrunsItem.averageSoftSortEventsDuration);
+                        }
+
+                        return packrunsItem.averageSoftSortEventsDuration;
+                      }();
+                    } else {
+                      packrunsItemObject.averageSoftSortEventsDuration = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalSoftSortEventsDuration' in packrunsItem) {
+                      packrunsItemObject.totalSoftSortEventsDuration = function () {
+                        if (typeof packrunsItem.totalSoftSortEventsDuration !== 'number') {
+                          return Number(packrunsItem.totalSoftSortEventsDuration);
+                        }
+
+                        return packrunsItem.totalSoftSortEventsDuration;
+                      }();
+                    } else {
+                      packrunsItemObject.totalSoftSortEventsDuration = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'softSortEventsAccurate' in packrunsItem) {
+                      packrunsItemObject.softSortEventsAccurate = function () {
+                        if (packrunsItem.softSortEventsAccurate === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.softSortEventsAccurate !== 'boolean') {
+                          return Boolean(packrunsItem.softSortEventsAccurate);
+                        }
+
+                        return packrunsItem.softSortEventsAccurate;
+                      }();
+                    } else {
+                      packrunsItemObject.softSortEventsAccurate = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'softSortEventsNotAccurateReason' in packrunsItem) {
+                      packrunsItemObject.softSortEventsNotAccurateReason = function () {
+                        if (packrunsItem.softSortEventsNotAccurateReason === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.softSortEventsNotAccurateReason !== 'string') {
+                          return String(packrunsItem.softSortEventsNotAccurateReason);
+                        }
+
+                        return packrunsItem.softSortEventsNotAccurateReason;
+                      }();
+                    } else {
+                      packrunsItemObject.softSortEventsNotAccurateReason = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1Percentage' in packrunsItem) {
+                      packrunsItemObject.class1Percentage = function () {
+                        if (typeof packrunsItem.class1Percentage !== 'number') {
+                          return Number(packrunsItem.class1Percentage);
+                        }
+
+                        return packrunsItem.class1Percentage;
+                      }();
+                    } else {
+                      packrunsItemObject.class1Percentage = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class2Percentage' in packrunsItem) {
+                      packrunsItemObject.class2Percentage = function () {
+                        if (typeof packrunsItem.class2Percentage !== 'number') {
+                          return Number(packrunsItem.class2Percentage);
+                        }
+
+                        return packrunsItem.class2Percentage;
+                      }();
+                    } else {
+                      packrunsItemObject.class2Percentage = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class3Percentage' in packrunsItem) {
+                      packrunsItemObject.class3Percentage = function () {
+                        if (typeof packrunsItem.class3Percentage !== 'number') {
+                          return Number(packrunsItem.class3Percentage);
+                        }
+
+                        return packrunsItem.class3Percentage;
+                      }();
+                    } else {
+                      packrunsItemObject.class3Percentage = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'nssPercentage' in packrunsItem) {
+                      packrunsItemObject.nssPercentage = function () {
+                        if (typeof packrunsItem.nssPercentage !== 'number') {
+                          return Number(packrunsItem.nssPercentage);
+                        }
+
+                        return packrunsItem.nssPercentage;
+                      }();
+                    } else {
+                      packrunsItemObject.nssPercentage = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'undersizePercentage' in packrunsItem) {
+                      packrunsItemObject.undersizePercentage = function () {
+                        if (typeof packrunsItem.undersizePercentage !== 'number') {
+                          return Number(packrunsItem.undersizePercentage);
+                        }
+
+                        return packrunsItem.undersizePercentage;
+                      }();
+                    } else {
+                      packrunsItemObject.undersizePercentage = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'cdmPercentage' in packrunsItem) {
+                      packrunsItemObject.cdmPercentage = function () {
+                        if (typeof packrunsItem.cdmPercentage !== 'number') {
+                          return Number(packrunsItem.cdmPercentage);
+                        }
+
+                        return packrunsItem.cdmPercentage;
+                      }();
+                    } else {
+                      packrunsItemObject.cdmPercentage = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'wastePercentage' in packrunsItem) {
+                      packrunsItemObject.wastePercentage = function () {
+                        if (typeof packrunsItem.wastePercentage !== 'number') {
+                          return Number(packrunsItem.wastePercentage);
+                        }
+
+                        return packrunsItem.wastePercentage;
+                      }();
+                    } else {
+                      packrunsItemObject.wastePercentage = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'softSortPercentage' in packrunsItem) {
+                      packrunsItemObject.softSortPercentage = function () {
+                        if (typeof packrunsItem.softSortPercentage !== 'number') {
+                          return Number(packrunsItem.softSortPercentage);
+                        }
+
+                        return packrunsItem.softSortPercentage;
+                      }();
+                    } else {
+                      packrunsItemObject.softSortPercentage = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalNonClass1Percentage' in packrunsItem) {
+                      packrunsItemObject.totalNonClass1Percentage = function () {
+                        if (typeof packrunsItem.totalNonClass1Percentage !== 'number') {
+                          return Number(packrunsItem.totalNonClass1Percentage);
+                        }
+
+                        return packrunsItem.totalNonClass1Percentage;
+                      }();
+                    } else {
+                      packrunsItemObject.totalNonClass1Percentage = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1Weight' in packrunsItem) {
+                      packrunsItemObject.class1Weight = function () {
+                        if (typeof packrunsItem.class1Weight !== 'number') {
+                          return Number(packrunsItem.class1Weight);
+                        }
+
+                        return packrunsItem.class1Weight;
+                      }();
+                    } else {
+                      packrunsItemObject.class1Weight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class2Weight' in packrunsItem) {
+                      packrunsItemObject.class2Weight = function () {
+                        if (typeof packrunsItem.class2Weight !== 'number') {
+                          return Number(packrunsItem.class2Weight);
+                        }
+
+                        return packrunsItem.class2Weight;
+                      }();
+                    } else {
+                      packrunsItemObject.class2Weight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class3Weight' in packrunsItem) {
+                      packrunsItemObject.class3Weight = function () {
+                        if (typeof packrunsItem.class3Weight !== 'number') {
+                          return Number(packrunsItem.class3Weight);
+                        }
+
+                        return packrunsItem.class3Weight;
+                      }();
+                    } else {
+                      packrunsItemObject.class3Weight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'nssWeight' in packrunsItem) {
+                      packrunsItemObject.nssWeight = function () {
+                        if (typeof packrunsItem.nssWeight !== 'number') {
+                          return Number(packrunsItem.nssWeight);
+                        }
+
+                        return packrunsItem.nssWeight;
+                      }();
+                    } else {
+                      packrunsItemObject.nssWeight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'undersizeWeight' in packrunsItem) {
+                      packrunsItemObject.undersizeWeight = function () {
+                        if (typeof packrunsItem.undersizeWeight !== 'number') {
+                          return Number(packrunsItem.undersizeWeight);
+                        }
+
+                        return packrunsItem.undersizeWeight;
+                      }();
+                    } else {
+                      packrunsItemObject.undersizeWeight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'cdmWeight' in packrunsItem) {
+                      packrunsItemObject.cdmWeight = function () {
+                        if (typeof packrunsItem.cdmWeight !== 'number') {
+                          return Number(packrunsItem.cdmWeight);
+                        }
+
+                        return packrunsItem.cdmWeight;
+                      }();
+                    } else {
+                      packrunsItemObject.cdmWeight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'wasteWeight' in packrunsItem) {
+                      packrunsItemObject.wasteWeight = function () {
+                        if (typeof packrunsItem.wasteWeight !== 'number') {
+                          return Number(packrunsItem.wasteWeight);
+                        }
+
+                        return packrunsItem.wasteWeight;
+                      }();
+                    } else {
+                      packrunsItemObject.wasteWeight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'softSortWeight' in packrunsItem) {
+                      packrunsItemObject.softSortWeight = function () {
+                        if (typeof packrunsItem.softSortWeight !== 'number') {
+                          return Number(packrunsItem.softSortWeight);
+                        }
+
+                        return packrunsItem.softSortWeight;
+                      }();
+                    } else {
+                      packrunsItemObject.softSortWeight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalNonClass1Weight' in packrunsItem) {
+                      packrunsItemObject.totalNonClass1Weight = function () {
+                        if (typeof packrunsItem.totalNonClass1Weight !== 'number') {
+                          return Number(packrunsItem.totalNonClass1Weight);
+                        }
+
+                        return packrunsItem.totalNonClass1Weight;
+                      }();
+                    } else {
+                      packrunsItemObject.totalNonClass1Weight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalClass1Trays' in packrunsItem) {
+                      packrunsItemObject.totalClass1Trays = function () {
+                        if (typeof packrunsItem.totalClass1Trays !== 'number') {
+                          return Number(packrunsItem.totalClass1Trays);
+                        }
+
+                        return packrunsItem.totalClass1Trays;
+                      }();
+                    } else {
+                      packrunsItemObject.totalClass1Trays = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalClass2Trays' in packrunsItem) {
+                      packrunsItemObject.totalClass2Trays = function () {
+                        if (typeof packrunsItem.totalClass2Trays !== 'number') {
+                          return Number(packrunsItem.totalClass2Trays);
+                        }
+
+                        return packrunsItem.totalClass2Trays;
+                      }();
+                    } else {
+                      packrunsItemObject.totalClass2Trays = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalClass1FruitCount' in packrunsItem) {
+                      packrunsItemObject.totalClass1FruitCount = function () {
+                        if (typeof packrunsItem.totalClass1FruitCount !== 'number') {
+                          return Number(packrunsItem.totalClass1FruitCount);
+                        }
+
+                        return packrunsItem.totalClass1FruitCount;
+                      }();
+                    } else {
+                      packrunsItemObject.totalClass1FruitCount = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalClass2FruitCount' in packrunsItem) {
+                      packrunsItemObject.totalClass2FruitCount = function () {
+                        if (typeof packrunsItem.totalClass2FruitCount !== 'number') {
+                          return Number(packrunsItem.totalClass2FruitCount);
+                        }
+
+                        return packrunsItem.totalClass2FruitCount;
+                      }();
+                    } else {
+                      packrunsItemObject.totalClass2FruitCount = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'averageClass1TrayWeight' in packrunsItem) {
+                      packrunsItemObject.averageClass1TrayWeight = function () {
+                        if (typeof packrunsItem.averageClass1TrayWeight !== 'number') {
+                          return Number(packrunsItem.averageClass1TrayWeight);
+                        }
+
+                        return packrunsItem.averageClass1TrayWeight;
+                      }();
+                    } else {
+                      packrunsItemObject.averageClass1TrayWeight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'averageClass2TrayWeight' in packrunsItem) {
+                      packrunsItemObject.averageClass2TrayWeight = function () {
+                        if (typeof packrunsItem.averageClass2TrayWeight !== 'number') {
+                          return Number(packrunsItem.averageClass2TrayWeight);
+                        }
+
+                        return packrunsItem.averageClass2TrayWeight;
+                      }();
+                    } else {
+                      packrunsItemObject.averageClass2TrayWeight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1TraysPerBin' in packrunsItem) {
+                      packrunsItemObject.class1TraysPerBin = function () {
+                        if (typeof packrunsItem.class1TraysPerBin !== 'number') {
+                          return Number(packrunsItem.class1TraysPerBin);
+                        }
+
+                        return packrunsItem.class1TraysPerBin;
+                      }();
+                    } else {
+                      packrunsItemObject.class1TraysPerBin = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'averageFruitSize' in packrunsItem) {
+                      packrunsItemObject.averageFruitSize = function () {
+                        if (typeof packrunsItem.averageFruitSize !== 'number') {
+                          return Number(packrunsItem.averageFruitSize);
+                        }
+
+                        return packrunsItem.averageFruitSize;
+                      }();
+                    } else {
+                      packrunsItemObject.averageFruitSize = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'averageFruitWeight' in packrunsItem) {
+                      packrunsItemObject.averageFruitWeight = function () {
+                        if (typeof packrunsItem.averageFruitWeight !== 'number') {
+                          return Number(packrunsItem.averageFruitWeight);
+                        }
+
+                        return packrunsItem.averageFruitWeight;
+                      }();
+                    } else {
+                      packrunsItemObject.averageFruitWeight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalRejectBinsCount' in packrunsItem) {
+                      packrunsItemObject.totalRejectBinsCount = function () {
+                        if (typeof packrunsItem.totalRejectBinsCount !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.totalRejectBinsCount)) ? Number(packrunsItem.totalRejectBinsCount) : Math.floor(Number(packrunsItem.totalRejectBinsCount));
+                        }
+
+                        return Number.isInteger(packrunsItem.totalRejectBinsCount) ? packrunsItem.totalRejectBinsCount : Math.floor(packrunsItem.totalRejectBinsCount);
+                      }();
+                    } else {
+                      packrunsItemObject.totalRejectBinsCount = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalRejectBinsNetWeight' in packrunsItem) {
+                      packrunsItemObject.totalRejectBinsNetWeight = function () {
+                        if (typeof packrunsItem.totalRejectBinsNetWeight !== 'number') {
+                          return Number(packrunsItem.totalRejectBinsNetWeight);
+                        }
+
+                        return packrunsItem.totalRejectBinsNetWeight;
+                      }();
+                    } else {
+                      packrunsItemObject.totalRejectBinsNetWeight = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityR600TotalFruitSampled' in packrunsItem) {
+                      packrunsItemObject.qualityR600TotalFruitSampled = function () {
+                        if (packrunsItem.qualityR600TotalFruitSampled === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityR600TotalFruitSampled !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.qualityR600TotalFruitSampled)) ? Number(packrunsItem.qualityR600TotalFruitSampled) : Math.floor(Number(packrunsItem.qualityR600TotalFruitSampled));
+                        }
+
+                        return Number.isInteger(packrunsItem.qualityR600TotalFruitSampled) ? packrunsItem.qualityR600TotalFruitSampled : Math.floor(packrunsItem.qualityR600TotalFruitSampled);
+                      }();
+                    } else {
+                      packrunsItemObject.qualityR600TotalFruitSampled = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityR600FruitSampledPercentage' in packrunsItem) {
+                      packrunsItemObject.qualityR600FruitSampledPercentage = function () {
+                        if (packrunsItem.qualityR600FruitSampledPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityR600FruitSampledPercentage !== 'number') {
+                          return Number(packrunsItem.qualityR600FruitSampledPercentage);
+                        }
+
+                        return packrunsItem.qualityR600FruitSampledPercentage;
+                      }();
+                    } else {
+                      packrunsItemObject.qualityR600FruitSampledPercentage = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityR600AverageSampledFruitSize' in packrunsItem) {
+                      packrunsItemObject.qualityR600AverageSampledFruitSize = function () {
+                        if (packrunsItem.qualityR600AverageSampledFruitSize === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityR600AverageSampledFruitSize !== 'number') {
+                          return Number(packrunsItem.qualityR600AverageSampledFruitSize);
+                        }
+
+                        return packrunsItem.qualityR600AverageSampledFruitSize;
+                      }();
+                    } else {
+                      packrunsItemObject.qualityR600AverageSampledFruitSize = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityR600TotalSamplesCount' in packrunsItem) {
+                      packrunsItemObject.qualityR600TotalSamplesCount = function () {
+                        if (packrunsItem.qualityR600TotalSamplesCount === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityR600TotalSamplesCount !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.qualityR600TotalSamplesCount)) ? Number(packrunsItem.qualityR600TotalSamplesCount) : Math.floor(Number(packrunsItem.qualityR600TotalSamplesCount));
+                        }
+
+                        return Number.isInteger(packrunsItem.qualityR600TotalSamplesCount) ? packrunsItem.qualityR600TotalSamplesCount : Math.floor(packrunsItem.qualityR600TotalSamplesCount);
+                      }();
+                    } else {
+                      packrunsItemObject.qualityR600TotalSamplesCount = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityR600IdealSamplesTarget' in packrunsItem) {
+                      packrunsItemObject.qualityR600IdealSamplesTarget = function () {
+                        if (packrunsItem.qualityR600IdealSamplesTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityR600IdealSamplesTarget !== 'number') {
+                          return Number(packrunsItem.qualityR600IdealSamplesTarget);
+                        }
+
+                        return packrunsItem.qualityR600IdealSamplesTarget;
+                      }();
+                    } else {
+                      packrunsItemObject.qualityR600IdealSamplesTarget = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityR600IdealSamplesActual' in packrunsItem) {
+                      packrunsItemObject.qualityR600IdealSamplesActual = function () {
+                        if (packrunsItem.qualityR600IdealSamplesActual === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityR600IdealSamplesActual !== 'number') {
+                          return Number(packrunsItem.qualityR600IdealSamplesActual);
+                        }
+
+                        return packrunsItem.qualityR600IdealSamplesActual;
+                      }();
+                    } else {
+                      packrunsItemObject.qualityR600IdealSamplesActual = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityR600MinorPackingDefects' in packrunsItem) {
+                      packrunsItemObject.qualityR600MinorPackingDefects = function () {
+                        if (packrunsItem.qualityR600MinorPackingDefects === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityR600MinorPackingDefects !== 'number') {
+                          return Number(packrunsItem.qualityR600MinorPackingDefects);
+                        }
+
+                        return packrunsItem.qualityR600MinorPackingDefects;
+                      }();
+                    } else {
+                      packrunsItemObject.qualityR600MinorPackingDefects = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityR600MajorPackingDefects' in packrunsItem) {
+                      packrunsItemObject.qualityR600MajorPackingDefects = function () {
+                        if (packrunsItem.qualityR600MajorPackingDefects === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityR600MajorPackingDefects !== 'number') {
+                          return Number(packrunsItem.qualityR600MajorPackingDefects);
+                        }
+
+                        return packrunsItem.qualityR600MajorPackingDefects;
+                      }();
+                    } else {
+                      packrunsItemObject.qualityR600MajorPackingDefects = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityR600Softs' in packrunsItem) {
+                      packrunsItemObject.qualityR600Softs = function () {
+                        if (packrunsItem.qualityR600Softs === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityR600Softs !== 'number') {
+                          return Number(packrunsItem.qualityR600Softs);
+                        }
+
+                        return packrunsItem.qualityR600Softs;
+                      }();
+                    } else {
+                      packrunsItemObject.qualityR600Softs = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityR600Cuts' in packrunsItem) {
+                      packrunsItemObject.qualityR600Cuts = function () {
+                        if (packrunsItem.qualityR600Cuts === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityR600Cuts !== 'number') {
+                          return Number(packrunsItem.qualityR600Cuts);
+                        }
+
+                        return packrunsItem.qualityR600Cuts;
+                      }();
+                    } else {
+                      packrunsItemObject.qualityR600Cuts = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityR600Rots' in packrunsItem) {
+                      packrunsItemObject.qualityR600Rots = function () {
+                        if (packrunsItem.qualityR600Rots === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityR600Rots !== 'number') {
+                          return Number(packrunsItem.qualityR600Rots);
+                        }
+
+                        return packrunsItem.qualityR600Rots;
+                      }();
+                    } else {
+                      packrunsItemObject.qualityR600Rots = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityExportFruitInClass2' in packrunsItem) {
+                      packrunsItemObject.qualityExportFruitInClass2 = function () {
+                        if (packrunsItem.qualityExportFruitInClass2 === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityExportFruitInClass2 !== 'number') {
+                          return Number(packrunsItem.qualityExportFruitInClass2);
+                        }
+
+                        return packrunsItem.qualityExportFruitInClass2;
+                      }();
+                    } else {
+                      packrunsItemObject.qualityExportFruitInClass2 = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityExportFruitInClass3' in packrunsItem) {
+                      packrunsItemObject.qualityExportFruitInClass3 = function () {
+                        if (packrunsItem.qualityExportFruitInClass3 === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityExportFruitInClass3 !== 'number') {
+                          return Number(packrunsItem.qualityExportFruitInClass3);
+                        }
+
+                        return packrunsItem.qualityExportFruitInClass3;
+                      }();
+                    } else {
+                      packrunsItemObject.qualityExportFruitInClass3 = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityExportFruitInWaste' in packrunsItem) {
+                      packrunsItemObject.qualityExportFruitInWaste = function () {
+                        if (packrunsItem.qualityExportFruitInWaste === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.qualityExportFruitInWaste !== 'number') {
+                          return Number(packrunsItem.qualityExportFruitInWaste);
+                        }
+
+                        return packrunsItem.qualityExportFruitInWaste;
+                      }();
+                    } else {
+                      packrunsItemObject.qualityExportFruitInWaste = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'shiftIds' in packrunsItem) {
+                      packrunsItemObject.shiftIds = function () {
+                        if (Array.isArray(packrunsItem.shiftIds) !== true) {
+                          return [];
+                        }
+
+                        return packrunsItem.shiftIds.map(function (shiftIdsItem) {
+                          return function () {
+                            if (typeof shiftIdsItem !== 'string') {
+                              return String(shiftIdsItem);
+                            }
+
+                            return shiftIdsItem;
+                          }();
+                        });
+                      }();
+                    } else {
+                      packrunsItemObject.shiftIds = [];
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'shiftTypes' in packrunsItem) {
+                      packrunsItemObject.shiftTypes = function () {
+                        if (Array.isArray(packrunsItem.shiftTypes) !== true) {
+                          return [];
+                        }
+
+                        return packrunsItem.shiftTypes.map(function (shiftTypesItem) {
+                          return function () {
+                            if (typeof shiftTypesItem !== 'string') {
+                              return String(shiftTypesItem);
+                            }
+
+                            return shiftTypesItem;
+                          }();
+                        });
+                      }();
+                    } else {
+                      packrunsItemObject.shiftTypes = [];
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'lineManagerNames' in packrunsItem) {
+                      packrunsItemObject.lineManagerNames = function () {
+                        if (Array.isArray(packrunsItem.lineManagerNames) !== true) {
+                          return [];
+                        }
+
+                        return packrunsItem.lineManagerNames.map(function (lineManagerNamesItem) {
+                          return function () {
+                            if (typeof lineManagerNamesItem !== 'string') {
+                              return String(lineManagerNamesItem);
+                            }
+
+                            return lineManagerNamesItem;
+                          }();
+                        });
+                      }();
+                    } else {
+                      packrunsItemObject.lineManagerNames = [];
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'qualityManagerNames' in packrunsItem) {
+                      packrunsItemObject.qualityManagerNames = function () {
+                        if (Array.isArray(packrunsItem.qualityManagerNames) !== true) {
+                          return [];
+                        }
+
+                        return packrunsItem.qualityManagerNames.map(function (qualityManagerNamesItem) {
+                          return function () {
+                            if (typeof qualityManagerNamesItem !== 'string') {
+                              return String(qualityManagerNamesItem);
+                            }
+
+                            return qualityManagerNamesItem;
+                          }();
+                        });
+                      }();
+                    } else {
+                      packrunsItemObject.qualityManagerNames = [];
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalProductionTime' in packrunsItem) {
+                      packrunsItemObject.totalProductionTime = function () {
+                        if (typeof packrunsItem.totalProductionTime !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.totalProductionTime)) ? Number(packrunsItem.totalProductionTime) : Math.floor(Number(packrunsItem.totalProductionTime));
+                        }
+
+                        return Number.isInteger(packrunsItem.totalProductionTime) ? packrunsItem.totalProductionTime : Math.floor(packrunsItem.totalProductionTime);
+                      }();
+                    } else {
+                      packrunsItemObject.totalProductionTime = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalScheduledBreakTime' in packrunsItem) {
+                      packrunsItemObject.totalScheduledBreakTime = function () {
+                        if (typeof packrunsItem.totalScheduledBreakTime !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.totalScheduledBreakTime)) ? Number(packrunsItem.totalScheduledBreakTime) : Math.floor(Number(packrunsItem.totalScheduledBreakTime));
+                        }
+
+                        return Number.isInteger(packrunsItem.totalScheduledBreakTime) ? packrunsItem.totalScheduledBreakTime : Math.floor(packrunsItem.totalScheduledBreakTime);
+                      }();
+                    } else {
+                      packrunsItemObject.totalScheduledBreakTime = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalDowntime' in packrunsItem) {
+                      packrunsItemObject.totalDowntime = function () {
+                        if (typeof packrunsItem.totalDowntime !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.totalDowntime)) ? Number(packrunsItem.totalDowntime) : Math.floor(Number(packrunsItem.totalDowntime));
+                        }
+
+                        return Number.isInteger(packrunsItem.totalDowntime) ? packrunsItem.totalDowntime : Math.floor(packrunsItem.totalDowntime);
+                      }();
+                    } else {
+                      packrunsItemObject.totalDowntime = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'downtimeEventsCount' in packrunsItem) {
+                      packrunsItemObject.downtimeEventsCount = function () {
+                        if (typeof packrunsItem.downtimeEventsCount !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.downtimeEventsCount)) ? Number(packrunsItem.downtimeEventsCount) : Math.floor(Number(packrunsItem.downtimeEventsCount));
+                        }
+
+                        return Number.isInteger(packrunsItem.downtimeEventsCount) ? packrunsItem.downtimeEventsCount : Math.floor(packrunsItem.downtimeEventsCount);
+                      }();
+                    } else {
+                      packrunsItemObject.downtimeEventsCount = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'downtimeEventsAverageDuration' in packrunsItem) {
+                      packrunsItemObject.downtimeEventsAverageDuration = function () {
+                        if (typeof packrunsItem.downtimeEventsAverageDuration !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.downtimeEventsAverageDuration)) ? Number(packrunsItem.downtimeEventsAverageDuration) : Math.floor(Number(packrunsItem.downtimeEventsAverageDuration));
+                        }
+
+                        return Number.isInteger(packrunsItem.downtimeEventsAverageDuration) ? packrunsItem.downtimeEventsAverageDuration : Math.floor(packrunsItem.downtimeEventsAverageDuration);
+                      }();
+                    } else {
+                      packrunsItemObject.downtimeEventsAverageDuration = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1ManningTarget' in packrunsItem) {
+                      packrunsItemObject.class1ManningTarget = function () {
+                        if (packrunsItem.class1ManningTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class1ManningTarget !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.class1ManningTarget)) ? Number(packrunsItem.class1ManningTarget) : Math.floor(Number(packrunsItem.class1ManningTarget));
+                        }
+
+                        return Number.isInteger(packrunsItem.class1ManningTarget) ? packrunsItem.class1ManningTarget : Math.floor(packrunsItem.class1ManningTarget);
+                      }();
+                    } else {
+                      packrunsItemObject.class1ManningTarget = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'averageClass1Manning' in packrunsItem) {
+                      packrunsItemObject.averageClass1Manning = function () {
+                        if (packrunsItem.averageClass1Manning === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.averageClass1Manning !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.averageClass1Manning)) ? Number(packrunsItem.averageClass1Manning) : Math.floor(Number(packrunsItem.averageClass1Manning));
+                        }
+
+                        return Number.isInteger(packrunsItem.averageClass1Manning) ? packrunsItem.averageClass1Manning : Math.floor(packrunsItem.averageClass1Manning);
+                      }();
+                    } else {
+                      packrunsItemObject.averageClass1Manning = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1ManningPercentage' in packrunsItem) {
+                      packrunsItemObject.class1ManningPercentage = function () {
+                        if (packrunsItem.class1ManningPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class1ManningPercentage !== 'number') {
+                          return Number(packrunsItem.class1ManningPercentage);
+                        }
+
+                        return packrunsItem.class1ManningPercentage;
+                      }();
+                    } else {
+                      packrunsItemObject.class1ManningPercentage = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class2ManningTarget' in packrunsItem) {
+                      packrunsItemObject.class2ManningTarget = function () {
+                        if (packrunsItem.class2ManningTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class2ManningTarget !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.class2ManningTarget)) ? Number(packrunsItem.class2ManningTarget) : Math.floor(Number(packrunsItem.class2ManningTarget));
+                        }
+
+                        return Number.isInteger(packrunsItem.class2ManningTarget) ? packrunsItem.class2ManningTarget : Math.floor(packrunsItem.class2ManningTarget);
+                      }();
+                    } else {
+                      packrunsItemObject.class2ManningTarget = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'averageClass2Manning' in packrunsItem) {
+                      packrunsItemObject.averageClass2Manning = function () {
+                        if (packrunsItem.averageClass2Manning === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.averageClass2Manning !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.averageClass2Manning)) ? Number(packrunsItem.averageClass2Manning) : Math.floor(Number(packrunsItem.averageClass2Manning));
+                        }
+
+                        return Number.isInteger(packrunsItem.averageClass2Manning) ? packrunsItem.averageClass2Manning : Math.floor(packrunsItem.averageClass2Manning);
+                      }();
+                    } else {
+                      packrunsItemObject.averageClass2Manning = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class2ManningPercentage' in packrunsItem) {
+                      packrunsItemObject.class2ManningPercentage = function () {
+                        if (packrunsItem.class2ManningPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class2ManningPercentage !== 'number') {
+                          return Number(packrunsItem.class2ManningPercentage);
+                        }
+
+                        return packrunsItem.class2ManningPercentage;
+                      }();
+                    } else {
+                      packrunsItemObject.class2ManningPercentage = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalManningTarget' in packrunsItem) {
+                      packrunsItemObject.totalManningTarget = function () {
+                        if (packrunsItem.totalManningTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.totalManningTarget !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.totalManningTarget)) ? Number(packrunsItem.totalManningTarget) : Math.floor(Number(packrunsItem.totalManningTarget));
+                        }
+
+                        return Number.isInteger(packrunsItem.totalManningTarget) ? packrunsItem.totalManningTarget : Math.floor(packrunsItem.totalManningTarget);
+                      }();
+                    } else {
+                      packrunsItemObject.totalManningTarget = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'averageTotalManning' in packrunsItem) {
+                      packrunsItemObject.averageTotalManning = function () {
+                        if (packrunsItem.averageTotalManning === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.averageTotalManning !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.averageTotalManning)) ? Number(packrunsItem.averageTotalManning) : Math.floor(Number(packrunsItem.averageTotalManning));
+                        }
+
+                        return Number.isInteger(packrunsItem.averageTotalManning) ? packrunsItem.averageTotalManning : Math.floor(packrunsItem.averageTotalManning);
+                      }();
+                    } else {
+                      packrunsItemObject.averageTotalManning = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalManningPercentage' in packrunsItem) {
+                      packrunsItemObject.totalManningPercentage = function () {
+                        if (packrunsItem.totalManningPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.totalManningPercentage !== 'number') {
+                          return Number(packrunsItem.totalManningPercentage);
+                        }
+
+                        return packrunsItem.totalManningPercentage;
+                      }();
+                    } else {
+                      packrunsItemObject.totalManningPercentage = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'costPerManningUnitHour' in packrunsItem) {
+                      packrunsItemObject.costPerManningUnitHour = function () {
+                        if (packrunsItem.costPerManningUnitHour === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.costPerManningUnitHour !== 'number') {
+                          return Number(packrunsItem.costPerManningUnitHour);
+                        }
+
+                        return packrunsItem.costPerManningUnitHour;
+                      }();
+                    } else {
+                      packrunsItemObject.costPerManningUnitHour = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalHoursWorked' in packrunsItem) {
+                      packrunsItemObject.totalHoursWorked = function () {
+                        if (typeof packrunsItem.totalHoursWorked !== 'number') {
+                          return Number(packrunsItem.totalHoursWorked);
+                        }
+
+                        return packrunsItem.totalHoursWorked;
+                      }();
+                    } else {
+                      packrunsItemObject.totalHoursWorked = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalHoursWorkedExcludingDowntime' in packrunsItem) {
+                      packrunsItemObject.totalHoursWorkedExcludingDowntime = function () {
+                        if (typeof packrunsItem.totalHoursWorkedExcludingDowntime !== 'number') {
+                          return Number(packrunsItem.totalHoursWorkedExcludingDowntime);
+                        }
+
+                        return packrunsItem.totalHoursWorkedExcludingDowntime;
+                      }();
+                    } else {
+                      packrunsItemObject.totalHoursWorkedExcludingDowntime = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'totalHoursPaid' in packrunsItem) {
+                      packrunsItemObject.totalHoursPaid = function () {
+                        if (typeof packrunsItem.totalHoursPaid !== 'number') {
+                          return Number(packrunsItem.totalHoursPaid);
+                        }
+
+                        return packrunsItem.totalHoursPaid;
+                      }();
+                    } else {
+                      packrunsItemObject.totalHoursPaid = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1TotalManningCost' in packrunsItem) {
+                      packrunsItemObject.class1TotalManningCost = function () {
+                        if (packrunsItem.class1TotalManningCost === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class1TotalManningCost !== 'number') {
+                          return Number(packrunsItem.class1TotalManningCost);
+                        }
+
+                        return packrunsItem.class1TotalManningCost;
+                      }();
+                    } else {
+                      packrunsItemObject.class1TotalManningCost = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class2TotalManningCost' in packrunsItem) {
+                      packrunsItemObject.class2TotalManningCost = function () {
+                        if (packrunsItem.class2TotalManningCost === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class2TotalManningCost !== 'number') {
+                          return Number(packrunsItem.class2TotalManningCost);
+                        }
+
+                        return packrunsItem.class2TotalManningCost;
+                      }();
+                    } else {
+                      packrunsItemObject.class2TotalManningCost = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1DowntimeManningCost' in packrunsItem) {
+                      packrunsItemObject.class1DowntimeManningCost = function () {
+                        if (packrunsItem.class1DowntimeManningCost === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class1DowntimeManningCost !== 'number') {
+                          return Number(packrunsItem.class1DowntimeManningCost);
+                        }
+
+                        return packrunsItem.class1DowntimeManningCost;
+                      }();
+                    } else {
+                      packrunsItemObject.class1DowntimeManningCost = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class2DowntimeManningCost' in packrunsItem) {
+                      packrunsItemObject.class2DowntimeManningCost = function () {
+                        if (packrunsItem.class2DowntimeManningCost === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class2DowntimeManningCost !== 'number') {
+                          return Number(packrunsItem.class2DowntimeManningCost);
+                        }
+
+                        return packrunsItem.class2DowntimeManningCost;
+                      }();
+                    } else {
+                      packrunsItemObject.class2DowntimeManningCost = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1CostPerTrayTarget' in packrunsItem) {
+                      packrunsItemObject.class1CostPerTrayTarget = function () {
+                        if (packrunsItem.class1CostPerTrayTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class1CostPerTrayTarget !== 'number') {
+                          return Number(packrunsItem.class1CostPerTrayTarget);
+                        }
+
+                        return packrunsItem.class1CostPerTrayTarget;
+                      }();
+                    } else {
+                      packrunsItemObject.class1CostPerTrayTarget = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1CostPerTrayActual' in packrunsItem) {
+                      packrunsItemObject.class1CostPerTrayActual = function () {
+                        if (packrunsItem.class1CostPerTrayActual === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class1CostPerTrayActual !== 'number') {
+                          return Number(packrunsItem.class1CostPerTrayActual);
+                        }
+
+                        return packrunsItem.class1CostPerTrayActual;
+                      }();
+                    } else {
+                      packrunsItemObject.class1CostPerTrayActual = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class2CostPerTrayActual' in packrunsItem) {
+                      packrunsItemObject.class2CostPerTrayActual = function () {
+                        if (packrunsItem.class2CostPerTrayActual === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class2CostPerTrayActual !== 'number') {
+                          return Number(packrunsItem.class2CostPerTrayActual);
+                        }
+
+                        return packrunsItem.class2CostPerTrayActual;
+                      }();
+                    } else {
+                      packrunsItemObject.class2CostPerTrayActual = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1TraysPerHour' in packrunsItem) {
+                      packrunsItemObject.class1TraysPerHour = function () {
+                        if (typeof packrunsItem.class1TraysPerHour !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.class1TraysPerHour)) ? Number(packrunsItem.class1TraysPerHour) : Math.floor(Number(packrunsItem.class1TraysPerHour));
+                        }
+
+                        return Number.isInteger(packrunsItem.class1TraysPerHour) ? packrunsItem.class1TraysPerHour : Math.floor(packrunsItem.class1TraysPerHour);
+                      }();
+                    } else {
+                      packrunsItemObject.class1TraysPerHour = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1TraysPerHourExcludingDowntime' in packrunsItem) {
+                      packrunsItemObject.class1TraysPerHourExcludingDowntime = function () {
+                        if (typeof packrunsItem.class1TraysPerHourExcludingDowntime !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.class1TraysPerHourExcludingDowntime)) ? Number(packrunsItem.class1TraysPerHourExcludingDowntime) : Math.floor(Number(packrunsItem.class1TraysPerHourExcludingDowntime));
+                        }
+
+                        return Number.isInteger(packrunsItem.class1TraysPerHourExcludingDowntime) ? packrunsItem.class1TraysPerHourExcludingDowntime : Math.floor(packrunsItem.class1TraysPerHourExcludingDowntime);
+                      }();
+                    } else {
+                      packrunsItemObject.class1TraysPerHourExcludingDowntime = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1TraysPerHourExcludingDowntimeTarget' in packrunsItem) {
+                      packrunsItemObject.class1TraysPerHourExcludingDowntimeTarget = function () {
+                        if (typeof packrunsItem.class1TraysPerHourExcludingDowntimeTarget !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.class1TraysPerHourExcludingDowntimeTarget)) ? Number(packrunsItem.class1TraysPerHourExcludingDowntimeTarget) : Math.floor(Number(packrunsItem.class1TraysPerHourExcludingDowntimeTarget));
+                        }
+
+                        return Number.isInteger(packrunsItem.class1TraysPerHourExcludingDowntimeTarget) ? packrunsItem.class1TraysPerHourExcludingDowntimeTarget : Math.floor(packrunsItem.class1TraysPerHourExcludingDowntimeTarget);
+                      }();
+                    } else {
+                      packrunsItemObject.class1TraysPerHourExcludingDowntimeTarget = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1TraysPerManHour' in packrunsItem) {
+                      packrunsItemObject.class1TraysPerManHour = function () {
+                        if (packrunsItem.class1TraysPerManHour === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class1TraysPerManHour !== 'number') {
+                          return Number(packrunsItem.class1TraysPerManHour);
+                        }
+
+                        return packrunsItem.class1TraysPerManHour;
+                      }();
+                    } else {
+                      packrunsItemObject.class1TraysPerManHour = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1TraysPerManHourExcludingDowntime' in packrunsItem) {
+                      packrunsItemObject.class1TraysPerManHourExcludingDowntime = function () {
+                        if (packrunsItem.class1TraysPerManHourExcludingDowntime === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class1TraysPerManHourExcludingDowntime !== 'number') {
+                          return Number(packrunsItem.class1TraysPerManHourExcludingDowntime);
+                        }
+
+                        return packrunsItem.class1TraysPerManHourExcludingDowntime;
+                      }();
+                    } else {
+                      packrunsItemObject.class1TraysPerManHourExcludingDowntime = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class2TraysPerHour' in packrunsItem) {
+                      packrunsItemObject.class2TraysPerHour = function () {
+                        if (typeof packrunsItem.class2TraysPerHour !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.class2TraysPerHour)) ? Number(packrunsItem.class2TraysPerHour) : Math.floor(Number(packrunsItem.class2TraysPerHour));
+                        }
+
+                        return Number.isInteger(packrunsItem.class2TraysPerHour) ? packrunsItem.class2TraysPerHour : Math.floor(packrunsItem.class2TraysPerHour);
+                      }();
+                    } else {
+                      packrunsItemObject.class2TraysPerHour = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class2TraysPerHourExcludingDowntime' in packrunsItem) {
+                      packrunsItemObject.class2TraysPerHourExcludingDowntime = function () {
+                        if (typeof packrunsItem.class2TraysPerHourExcludingDowntime !== 'number') {
+                          return Number.isInteger(Number(packrunsItem.class2TraysPerHourExcludingDowntime)) ? Number(packrunsItem.class2TraysPerHourExcludingDowntime) : Math.floor(Number(packrunsItem.class2TraysPerHourExcludingDowntime));
+                        }
+
+                        return Number.isInteger(packrunsItem.class2TraysPerHourExcludingDowntime) ? packrunsItem.class2TraysPerHourExcludingDowntime : Math.floor(packrunsItem.class2TraysPerHourExcludingDowntime);
+                      }();
+                    } else {
+                      packrunsItemObject.class2TraysPerHourExcludingDowntime = 0;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class2TraysPerManHour' in packrunsItem) {
+                      packrunsItemObject.class2TraysPerManHour = function () {
+                        if (packrunsItem.class2TraysPerManHour === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class2TraysPerManHour !== 'number') {
+                          return Number(packrunsItem.class2TraysPerManHour);
+                        }
+
+                        return packrunsItem.class2TraysPerManHour;
+                      }();
+                    } else {
+                      packrunsItemObject.class2TraysPerManHour = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class2TraysPerManHourExcludingDowntime' in packrunsItem) {
+                      packrunsItemObject.class2TraysPerManHourExcludingDowntime = function () {
+                        if (packrunsItem.class2TraysPerManHourExcludingDowntime === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class2TraysPerManHourExcludingDowntime !== 'number') {
+                          return Number(packrunsItem.class2TraysPerManHourExcludingDowntime);
+                        }
+
+                        return packrunsItem.class2TraysPerManHourExcludingDowntime;
+                      }();
+                    } else {
+                      packrunsItemObject.class2TraysPerManHourExcludingDowntime = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1LayeredPercentageTarget' in packrunsItem) {
+                      packrunsItemObject.class1LayeredPercentageTarget = function () {
+                        if (packrunsItem.class1LayeredPercentageTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class1LayeredPercentageTarget !== 'number') {
+                          return Number(packrunsItem.class1LayeredPercentageTarget);
+                        }
+
+                        return packrunsItem.class1LayeredPercentageTarget;
+                      }();
+                    } else {
+                      packrunsItemObject.class1LayeredPercentageTarget = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1LayeredPercentage' in packrunsItem) {
+                      packrunsItemObject.class1LayeredPercentage = function () {
+                        if (packrunsItem.class1LayeredPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class1LayeredPercentage !== 'number') {
+                          return Number(packrunsItem.class1LayeredPercentage);
+                        }
+
+                        return packrunsItem.class1LayeredPercentage;
+                      }();
+                    } else {
+                      packrunsItemObject.class1LayeredPercentage = null;
+                    }
+
+                    if (_typeof(packrunsItem) === 'object' && 'class1BulkPercentage' in packrunsItem) {
+                      packrunsItemObject.class1BulkPercentage = function () {
+                        if (packrunsItem.class1BulkPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof packrunsItem.class1BulkPercentage !== 'number') {
+                          return Number(packrunsItem.class1BulkPercentage);
+                        }
+
+                        return packrunsItem.class1BulkPercentage;
+                      }();
+                    } else {
+                      packrunsItemObject.class1BulkPercentage = null;
+                    }
+
+                    return packrunsItemObject;
+                  }();
+                });
+              }();
+            } else {
+              resultObject.packruns = [];
+            }
+
+            if (_typeof(result) === 'object' && 'shifts' in result) {
+              resultObject.shifts = function () {
+                if (Array.isArray(result.shifts) !== true) {
+                  return [];
+                }
+
+                return result.shifts.map(function (shiftsItem) {
+                  return function () {
+                    var shiftsItemObject = {};
+
+                    if (_typeof(shiftsItem) === 'object' && 'siteId' in shiftsItem) {
+                      shiftsItemObject.siteId = function () {
+                        if (typeof shiftsItem.siteId !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.siteId)) ? Number(shiftsItem.siteId) : Math.floor(Number(shiftsItem.siteId));
+                        }
+
+                        return Number.isInteger(shiftsItem.siteId) ? shiftsItem.siteId : Math.floor(shiftsItem.siteId);
+                      }();
+                    } else {
+                      shiftsItemObject.siteId = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'siteName' in shiftsItem) {
+                      shiftsItemObject.siteName = function () {
+                        if (typeof shiftsItem.siteName !== 'string') {
+                          return String(shiftsItem.siteName);
+                        }
+
+                        return shiftsItem.siteName;
+                      }();
+                    } else {
+                      shiftsItemObject.siteName = "";
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'packingLineId' in shiftsItem) {
+                      shiftsItemObject.packingLineId = function () {
+                        if (typeof shiftsItem.packingLineId !== 'string') {
+                          return String(shiftsItem.packingLineId);
+                        }
+
+                        return shiftsItem.packingLineId;
+                      }();
+                    } else {
+                      shiftsItemObject.packingLineId = "";
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'packingLineName' in shiftsItem) {
+                      shiftsItemObject.packingLineName = function () {
+                        if (typeof shiftsItem.packingLineName !== 'string') {
+                          return String(shiftsItem.packingLineName);
+                        }
+
+                        return shiftsItem.packingLineName;
+                      }();
+                    } else {
+                      shiftsItemObject.packingLineName = "";
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'shiftId' in shiftsItem) {
+                      shiftsItemObject.shiftId = function () {
+                        if (typeof shiftsItem.shiftId !== 'string') {
+                          return String(shiftsItem.shiftId);
+                        }
+
+                        return shiftsItem.shiftId;
+                      }();
+                    } else {
+                      shiftsItemObject.shiftId = "";
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'shiftType' in shiftsItem) {
+                      shiftsItemObject.shiftType = function () {
+                        if (typeof shiftsItem.shiftType !== 'string') {
+                          return String(shiftsItem.shiftType);
+                        }
+
+                        return shiftsItem.shiftType;
+                      }();
+                    } else {
+                      shiftsItemObject.shiftType = "";
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'isoWeek' in shiftsItem) {
+                      shiftsItemObject.isoWeek = function () {
+                        if (typeof shiftsItem.isoWeek !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.isoWeek)) ? Number(shiftsItem.isoWeek) : Math.floor(Number(shiftsItem.isoWeek));
+                        }
+
+                        return Number.isInteger(shiftsItem.isoWeek) ? shiftsItem.isoWeek : Math.floor(shiftsItem.isoWeek);
+                      }();
+                    } else {
+                      shiftsItemObject.isoWeek = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'startTimestamp' in shiftsItem) {
+                      shiftsItemObject.startTimestamp = function () {
+                        if (typeof shiftsItem.startTimestamp !== 'string') {
+                          return new Date(String(shiftsItem.startTimestamp));
+                        }
+
+                        return new Date(shiftsItem.startTimestamp);
+                      }();
+                    } else {
+                      shiftsItemObject.startTimestamp = new Date();
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'finishTimestamp' in shiftsItem) {
+                      shiftsItemObject.finishTimestamp = function () {
+                        if (shiftsItem.finishTimestamp === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.finishTimestamp !== 'string') {
+                          return new Date(String(shiftsItem.finishTimestamp));
+                        }
+
+                        return new Date(shiftsItem.finishTimestamp);
+                      }();
+                    } else {
+                      shiftsItemObject.finishTimestamp = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'lineManagerName' in shiftsItem) {
+                      shiftsItemObject.lineManagerName = function () {
+                        if (shiftsItem.lineManagerName === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.lineManagerName !== 'string') {
+                          return String(shiftsItem.lineManagerName);
+                        }
+
+                        return shiftsItem.lineManagerName;
+                      }();
+                    } else {
+                      shiftsItemObject.lineManagerName = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'qualityManagerName' in shiftsItem) {
+                      shiftsItemObject.qualityManagerName = function () {
+                        if (shiftsItem.qualityManagerName === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.qualityManagerName !== 'string') {
+                          return String(shiftsItem.qualityManagerName);
+                        }
+
+                        return shiftsItem.qualityManagerName;
+                      }();
+                    } else {
+                      shiftsItemObject.qualityManagerName = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'varietyIds' in shiftsItem) {
+                      shiftsItemObject.varietyIds = function () {
+                        if (Array.isArray(shiftsItem.varietyIds) !== true) {
+                          return [];
+                        }
+
+                        return shiftsItem.varietyIds.map(function (varietyIdsItem) {
+                          return function () {
+                            if (typeof varietyIdsItem !== 'string') {
+                              return String(varietyIdsItem);
+                            }
+
+                            return varietyIdsItem;
+                          }();
+                        });
+                      }();
+                    } else {
+                      shiftsItemObject.varietyIds = [];
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'varietyCodes' in shiftsItem) {
+                      shiftsItemObject.varietyCodes = function () {
+                        if (Array.isArray(shiftsItem.varietyCodes) !== true) {
+                          return [];
+                        }
+
+                        return shiftsItem.varietyCodes.map(function (varietyCodesItem) {
+                          return function () {
+                            if (typeof varietyCodesItem !== 'string') {
+                              return String(varietyCodesItem);
+                            }
+
+                            return varietyCodesItem;
+                          }();
+                        });
+                      }();
+                    } else {
+                      shiftsItemObject.varietyCodes = [];
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'growingMethodIds' in shiftsItem) {
+                      shiftsItemObject.growingMethodIds = function () {
+                        if (Array.isArray(shiftsItem.growingMethodIds) !== true) {
+                          return [];
+                        }
+
+                        return shiftsItem.growingMethodIds.map(function (growingMethodIdsItem) {
+                          return function () {
+                            if (typeof growingMethodIdsItem !== 'string') {
+                              return String(growingMethodIdsItem);
+                            }
+
+                            return growingMethodIdsItem;
+                          }();
+                        });
+                      }();
+                    } else {
+                      shiftsItemObject.growingMethodIds = [];
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'growingMethodCodes' in shiftsItem) {
+                      shiftsItemObject.growingMethodCodes = function () {
+                        if (Array.isArray(shiftsItem.growingMethodCodes) !== true) {
+                          return [];
+                        }
+
+                        return shiftsItem.growingMethodCodes.map(function (growingMethodCodesItem) {
+                          return function () {
+                            if (typeof growingMethodCodesItem !== 'string') {
+                              return String(growingMethodCodesItem);
+                            }
+
+                            return growingMethodCodesItem;
+                          }();
+                        });
+                      }();
+                    } else {
+                      shiftsItemObject.growingMethodCodes = [];
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'binsTippedTarget' in shiftsItem) {
+                      shiftsItemObject.binsTippedTarget = function () {
+                        if (typeof shiftsItem.binsTippedTarget !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.binsTippedTarget)) ? Number(shiftsItem.binsTippedTarget) : Math.floor(Number(shiftsItem.binsTippedTarget));
+                        }
+
+                        return Number.isInteger(shiftsItem.binsTippedTarget) ? shiftsItem.binsTippedTarget : Math.floor(shiftsItem.binsTippedTarget);
+                      }();
+                    } else {
+                      shiftsItemObject.binsTippedTarget = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'totalBinsTipped' in shiftsItem) {
+                      shiftsItemObject.totalBinsTipped = function () {
+                        if (typeof shiftsItem.totalBinsTipped !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.totalBinsTipped)) ? Number(shiftsItem.totalBinsTipped) : Math.floor(Number(shiftsItem.totalBinsTipped));
+                        }
+
+                        return Number.isInteger(shiftsItem.totalBinsTipped) ? shiftsItem.totalBinsTipped : Math.floor(shiftsItem.totalBinsTipped);
+                      }();
+                    } else {
+                      shiftsItemObject.totalBinsTipped = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'binsTippedPerHour' in shiftsItem) {
+                      shiftsItemObject.binsTippedPerHour = function () {
+                        if (typeof shiftsItem.binsTippedPerHour !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.binsTippedPerHour)) ? Number(shiftsItem.binsTippedPerHour) : Math.floor(Number(shiftsItem.binsTippedPerHour));
+                        }
+
+                        return Number.isInteger(shiftsItem.binsTippedPerHour) ? shiftsItem.binsTippedPerHour : Math.floor(shiftsItem.binsTippedPerHour);
+                      }();
+                    } else {
+                      shiftsItemObject.binsTippedPerHour = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'binsTippedPerHourExcludingDowntime' in shiftsItem) {
+                      shiftsItemObject.binsTippedPerHourExcludingDowntime = function () {
+                        if (typeof shiftsItem.binsTippedPerHourExcludingDowntime !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.binsTippedPerHourExcludingDowntime)) ? Number(shiftsItem.binsTippedPerHourExcludingDowntime) : Math.floor(Number(shiftsItem.binsTippedPerHourExcludingDowntime));
+                        }
+
+                        return Number.isInteger(shiftsItem.binsTippedPerHourExcludingDowntime) ? shiftsItem.binsTippedPerHourExcludingDowntime : Math.floor(shiftsItem.binsTippedPerHourExcludingDowntime);
+                      }();
+                    } else {
+                      shiftsItemObject.binsTippedPerHourExcludingDowntime = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'totalProductionTime' in shiftsItem) {
+                      shiftsItemObject.totalProductionTime = function () {
+                        if (typeof shiftsItem.totalProductionTime !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.totalProductionTime)) ? Number(shiftsItem.totalProductionTime) : Math.floor(Number(shiftsItem.totalProductionTime));
+                        }
+
+                        return Number.isInteger(shiftsItem.totalProductionTime) ? shiftsItem.totalProductionTime : Math.floor(shiftsItem.totalProductionTime);
+                      }();
+                    } else {
+                      shiftsItemObject.totalProductionTime = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'totalScheduledBreakTime' in shiftsItem) {
+                      shiftsItemObject.totalScheduledBreakTime = function () {
+                        if (typeof shiftsItem.totalScheduledBreakTime !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.totalScheduledBreakTime)) ? Number(shiftsItem.totalScheduledBreakTime) : Math.floor(Number(shiftsItem.totalScheduledBreakTime));
+                        }
+
+                        return Number.isInteger(shiftsItem.totalScheduledBreakTime) ? shiftsItem.totalScheduledBreakTime : Math.floor(shiftsItem.totalScheduledBreakTime);
+                      }();
+                    } else {
+                      shiftsItemObject.totalScheduledBreakTime = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'totalDowntime' in shiftsItem) {
+                      shiftsItemObject.totalDowntime = function () {
+                        if (typeof shiftsItem.totalDowntime !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.totalDowntime)) ? Number(shiftsItem.totalDowntime) : Math.floor(Number(shiftsItem.totalDowntime));
+                        }
+
+                        return Number.isInteger(shiftsItem.totalDowntime) ? shiftsItem.totalDowntime : Math.floor(shiftsItem.totalDowntime);
+                      }();
+                    } else {
+                      shiftsItemObject.totalDowntime = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'downtimeEventsCount' in shiftsItem) {
+                      shiftsItemObject.downtimeEventsCount = function () {
+                        if (typeof shiftsItem.downtimeEventsCount !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.downtimeEventsCount)) ? Number(shiftsItem.downtimeEventsCount) : Math.floor(Number(shiftsItem.downtimeEventsCount));
+                        }
+
+                        return Number.isInteger(shiftsItem.downtimeEventsCount) ? shiftsItem.downtimeEventsCount : Math.floor(shiftsItem.downtimeEventsCount);
+                      }();
+                    } else {
+                      shiftsItemObject.downtimeEventsCount = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'downtimeEventsAverageDuration' in shiftsItem) {
+                      shiftsItemObject.downtimeEventsAverageDuration = function () {
+                        if (typeof shiftsItem.downtimeEventsAverageDuration !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.downtimeEventsAverageDuration)) ? Number(shiftsItem.downtimeEventsAverageDuration) : Math.floor(Number(shiftsItem.downtimeEventsAverageDuration));
+                        }
+
+                        return Number.isInteger(shiftsItem.downtimeEventsAverageDuration) ? shiftsItem.downtimeEventsAverageDuration : Math.floor(shiftsItem.downtimeEventsAverageDuration);
+                      }();
+                    } else {
+                      shiftsItemObject.downtimeEventsAverageDuration = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1ManningTarget' in shiftsItem) {
+                      shiftsItemObject.class1ManningTarget = function () {
+                        if (shiftsItem.class1ManningTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class1ManningTarget !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.class1ManningTarget)) ? Number(shiftsItem.class1ManningTarget) : Math.floor(Number(shiftsItem.class1ManningTarget));
+                        }
+
+                        return Number.isInteger(shiftsItem.class1ManningTarget) ? shiftsItem.class1ManningTarget : Math.floor(shiftsItem.class1ManningTarget);
+                      }();
+                    } else {
+                      shiftsItemObject.class1ManningTarget = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'averageClass1Manning' in shiftsItem) {
+                      shiftsItemObject.averageClass1Manning = function () {
+                        if (shiftsItem.averageClass1Manning === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.averageClass1Manning !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.averageClass1Manning)) ? Number(shiftsItem.averageClass1Manning) : Math.floor(Number(shiftsItem.averageClass1Manning));
+                        }
+
+                        return Number.isInteger(shiftsItem.averageClass1Manning) ? shiftsItem.averageClass1Manning : Math.floor(shiftsItem.averageClass1Manning);
+                      }();
+                    } else {
+                      shiftsItemObject.averageClass1Manning = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1ManningPercentage' in shiftsItem) {
+                      shiftsItemObject.class1ManningPercentage = function () {
+                        if (shiftsItem.class1ManningPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class1ManningPercentage !== 'number') {
+                          return Number(shiftsItem.class1ManningPercentage);
+                        }
+
+                        return shiftsItem.class1ManningPercentage;
+                      }();
+                    } else {
+                      shiftsItemObject.class1ManningPercentage = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class2ManningTarget' in shiftsItem) {
+                      shiftsItemObject.class2ManningTarget = function () {
+                        if (shiftsItem.class2ManningTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class2ManningTarget !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.class2ManningTarget)) ? Number(shiftsItem.class2ManningTarget) : Math.floor(Number(shiftsItem.class2ManningTarget));
+                        }
+
+                        return Number.isInteger(shiftsItem.class2ManningTarget) ? shiftsItem.class2ManningTarget : Math.floor(shiftsItem.class2ManningTarget);
+                      }();
+                    } else {
+                      shiftsItemObject.class2ManningTarget = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'averageClass2Manning' in shiftsItem) {
+                      shiftsItemObject.averageClass2Manning = function () {
+                        if (shiftsItem.averageClass2Manning === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.averageClass2Manning !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.averageClass2Manning)) ? Number(shiftsItem.averageClass2Manning) : Math.floor(Number(shiftsItem.averageClass2Manning));
+                        }
+
+                        return Number.isInteger(shiftsItem.averageClass2Manning) ? shiftsItem.averageClass2Manning : Math.floor(shiftsItem.averageClass2Manning);
+                      }();
+                    } else {
+                      shiftsItemObject.averageClass2Manning = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class2ManningPercentage' in shiftsItem) {
+                      shiftsItemObject.class2ManningPercentage = function () {
+                        if (shiftsItem.class2ManningPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class2ManningPercentage !== 'number') {
+                          return Number(shiftsItem.class2ManningPercentage);
+                        }
+
+                        return shiftsItem.class2ManningPercentage;
+                      }();
+                    } else {
+                      shiftsItemObject.class2ManningPercentage = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'totalManningTarget' in shiftsItem) {
+                      shiftsItemObject.totalManningTarget = function () {
+                        if (shiftsItem.totalManningTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.totalManningTarget !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.totalManningTarget)) ? Number(shiftsItem.totalManningTarget) : Math.floor(Number(shiftsItem.totalManningTarget));
+                        }
+
+                        return Number.isInteger(shiftsItem.totalManningTarget) ? shiftsItem.totalManningTarget : Math.floor(shiftsItem.totalManningTarget);
+                      }();
+                    } else {
+                      shiftsItemObject.totalManningTarget = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'averageTotalManning' in shiftsItem) {
+                      shiftsItemObject.averageTotalManning = function () {
+                        if (shiftsItem.averageTotalManning === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.averageTotalManning !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.averageTotalManning)) ? Number(shiftsItem.averageTotalManning) : Math.floor(Number(shiftsItem.averageTotalManning));
+                        }
+
+                        return Number.isInteger(shiftsItem.averageTotalManning) ? shiftsItem.averageTotalManning : Math.floor(shiftsItem.averageTotalManning);
+                      }();
+                    } else {
+                      shiftsItemObject.averageTotalManning = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'totalManningPercentage' in shiftsItem) {
+                      shiftsItemObject.totalManningPercentage = function () {
+                        if (shiftsItem.totalManningPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.totalManningPercentage !== 'number') {
+                          return Number(shiftsItem.totalManningPercentage);
+                        }
+
+                        return shiftsItem.totalManningPercentage;
+                      }();
+                    } else {
+                      shiftsItemObject.totalManningPercentage = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'costPerManningUnitHour' in shiftsItem) {
+                      shiftsItemObject.costPerManningUnitHour = function () {
+                        if (shiftsItem.costPerManningUnitHour === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.costPerManningUnitHour !== 'number') {
+                          return Number(shiftsItem.costPerManningUnitHour);
+                        }
+
+                        return shiftsItem.costPerManningUnitHour;
+                      }();
+                    } else {
+                      shiftsItemObject.costPerManningUnitHour = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'totalHoursWorked' in shiftsItem) {
+                      shiftsItemObject.totalHoursWorked = function () {
+                        if (typeof shiftsItem.totalHoursWorked !== 'number') {
+                          return Number(shiftsItem.totalHoursWorked);
+                        }
+
+                        return shiftsItem.totalHoursWorked;
+                      }();
+                    } else {
+                      shiftsItemObject.totalHoursWorked = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'totalHoursWorkedExcludingDowntime' in shiftsItem) {
+                      shiftsItemObject.totalHoursWorkedExcludingDowntime = function () {
+                        if (typeof shiftsItem.totalHoursWorkedExcludingDowntime !== 'number') {
+                          return Number(shiftsItem.totalHoursWorkedExcludingDowntime);
+                        }
+
+                        return shiftsItem.totalHoursWorkedExcludingDowntime;
+                      }();
+                    } else {
+                      shiftsItemObject.totalHoursWorkedExcludingDowntime = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'totalHoursPaid' in shiftsItem) {
+                      shiftsItemObject.totalHoursPaid = function () {
+                        if (typeof shiftsItem.totalHoursPaid !== 'number') {
+                          return Number(shiftsItem.totalHoursPaid);
+                        }
+
+                        return shiftsItem.totalHoursPaid;
+                      }();
+                    } else {
+                      shiftsItemObject.totalHoursPaid = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1TotalManningCost' in shiftsItem) {
+                      shiftsItemObject.class1TotalManningCost = function () {
+                        if (shiftsItem.class1TotalManningCost === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class1TotalManningCost !== 'number') {
+                          return Number(shiftsItem.class1TotalManningCost);
+                        }
+
+                        return shiftsItem.class1TotalManningCost;
+                      }();
+                    } else {
+                      shiftsItemObject.class1TotalManningCost = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class2TotalManningCost' in shiftsItem) {
+                      shiftsItemObject.class2TotalManningCost = function () {
+                        if (shiftsItem.class2TotalManningCost === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class2TotalManningCost !== 'number') {
+                          return Number(shiftsItem.class2TotalManningCost);
+                        }
+
+                        return shiftsItem.class2TotalManningCost;
+                      }();
+                    } else {
+                      shiftsItemObject.class2TotalManningCost = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1DowntimeManningCost' in shiftsItem) {
+                      shiftsItemObject.class1DowntimeManningCost = function () {
+                        if (shiftsItem.class1DowntimeManningCost === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class1DowntimeManningCost !== 'number') {
+                          return Number(shiftsItem.class1DowntimeManningCost);
+                        }
+
+                        return shiftsItem.class1DowntimeManningCost;
+                      }();
+                    } else {
+                      shiftsItemObject.class1DowntimeManningCost = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class2DowntimeManningCost' in shiftsItem) {
+                      shiftsItemObject.class2DowntimeManningCost = function () {
+                        if (shiftsItem.class2DowntimeManningCost === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class2DowntimeManningCost !== 'number') {
+                          return Number(shiftsItem.class2DowntimeManningCost);
+                        }
+
+                        return shiftsItem.class2DowntimeManningCost;
+                      }();
+                    } else {
+                      shiftsItemObject.class2DowntimeManningCost = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1CostPerTrayTarget' in shiftsItem) {
+                      shiftsItemObject.class1CostPerTrayTarget = function () {
+                        if (shiftsItem.class1CostPerTrayTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class1CostPerTrayTarget !== 'number') {
+                          return Number(shiftsItem.class1CostPerTrayTarget);
+                        }
+
+                        return shiftsItem.class1CostPerTrayTarget;
+                      }();
+                    } else {
+                      shiftsItemObject.class1CostPerTrayTarget = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1CostPerTrayActual' in shiftsItem) {
+                      shiftsItemObject.class1CostPerTrayActual = function () {
+                        if (shiftsItem.class1CostPerTrayActual === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class1CostPerTrayActual !== 'number') {
+                          return Number(shiftsItem.class1CostPerTrayActual);
+                        }
+
+                        return shiftsItem.class1CostPerTrayActual;
+                      }();
+                    } else {
+                      shiftsItemObject.class1CostPerTrayActual = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class2CostPerTrayActual' in shiftsItem) {
+                      shiftsItemObject.class2CostPerTrayActual = function () {
+                        if (shiftsItem.class2CostPerTrayActual === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class2CostPerTrayActual !== 'number') {
+                          return Number(shiftsItem.class2CostPerTrayActual);
+                        }
+
+                        return shiftsItem.class2CostPerTrayActual;
+                      }();
+                    } else {
+                      shiftsItemObject.class2CostPerTrayActual = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'totalClass1Trays' in shiftsItem) {
+                      shiftsItemObject.totalClass1Trays = function () {
+                        if (typeof shiftsItem.totalClass1Trays !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.totalClass1Trays)) ? Number(shiftsItem.totalClass1Trays) : Math.floor(Number(shiftsItem.totalClass1Trays));
+                        }
+
+                        return Number.isInteger(shiftsItem.totalClass1Trays) ? shiftsItem.totalClass1Trays : Math.floor(shiftsItem.totalClass1Trays);
+                      }();
+                    } else {
+                      shiftsItemObject.totalClass1Trays = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'totalClass2Trays' in shiftsItem) {
+                      shiftsItemObject.totalClass2Trays = function () {
+                        if (typeof shiftsItem.totalClass2Trays !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.totalClass2Trays)) ? Number(shiftsItem.totalClass2Trays) : Math.floor(Number(shiftsItem.totalClass2Trays));
+                        }
+
+                        return Number.isInteger(shiftsItem.totalClass2Trays) ? shiftsItem.totalClass2Trays : Math.floor(shiftsItem.totalClass2Trays);
+                      }();
+                    } else {
+                      shiftsItemObject.totalClass2Trays = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1TraysPerHour' in shiftsItem) {
+                      shiftsItemObject.class1TraysPerHour = function () {
+                        if (typeof shiftsItem.class1TraysPerHour !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.class1TraysPerHour)) ? Number(shiftsItem.class1TraysPerHour) : Math.floor(Number(shiftsItem.class1TraysPerHour));
+                        }
+
+                        return Number.isInteger(shiftsItem.class1TraysPerHour) ? shiftsItem.class1TraysPerHour : Math.floor(shiftsItem.class1TraysPerHour);
+                      }();
+                    } else {
+                      shiftsItemObject.class1TraysPerHour = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1TraysPerHourExcludingDowntime' in shiftsItem) {
+                      shiftsItemObject.class1TraysPerHourExcludingDowntime = function () {
+                        if (typeof shiftsItem.class1TraysPerHourExcludingDowntime !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.class1TraysPerHourExcludingDowntime)) ? Number(shiftsItem.class1TraysPerHourExcludingDowntime) : Math.floor(Number(shiftsItem.class1TraysPerHourExcludingDowntime));
+                        }
+
+                        return Number.isInteger(shiftsItem.class1TraysPerHourExcludingDowntime) ? shiftsItem.class1TraysPerHourExcludingDowntime : Math.floor(shiftsItem.class1TraysPerHourExcludingDowntime);
+                      }();
+                    } else {
+                      shiftsItemObject.class1TraysPerHourExcludingDowntime = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1TraysPerHourExcludingDowntimeTarget' in shiftsItem) {
+                      shiftsItemObject.class1TraysPerHourExcludingDowntimeTarget = function () {
+                        if (typeof shiftsItem.class1TraysPerHourExcludingDowntimeTarget !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.class1TraysPerHourExcludingDowntimeTarget)) ? Number(shiftsItem.class1TraysPerHourExcludingDowntimeTarget) : Math.floor(Number(shiftsItem.class1TraysPerHourExcludingDowntimeTarget));
+                        }
+
+                        return Number.isInteger(shiftsItem.class1TraysPerHourExcludingDowntimeTarget) ? shiftsItem.class1TraysPerHourExcludingDowntimeTarget : Math.floor(shiftsItem.class1TraysPerHourExcludingDowntimeTarget);
+                      }();
+                    } else {
+                      shiftsItemObject.class1TraysPerHourExcludingDowntimeTarget = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1TraysPerManHour' in shiftsItem) {
+                      shiftsItemObject.class1TraysPerManHour = function () {
+                        if (shiftsItem.class1TraysPerManHour === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class1TraysPerManHour !== 'number') {
+                          return Number(shiftsItem.class1TraysPerManHour);
+                        }
+
+                        return shiftsItem.class1TraysPerManHour;
+                      }();
+                    } else {
+                      shiftsItemObject.class1TraysPerManHour = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1TraysPerManHourExcludingDowntime' in shiftsItem) {
+                      shiftsItemObject.class1TraysPerManHourExcludingDowntime = function () {
+                        if (shiftsItem.class1TraysPerManHourExcludingDowntime === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class1TraysPerManHourExcludingDowntime !== 'number') {
+                          return Number(shiftsItem.class1TraysPerManHourExcludingDowntime);
+                        }
+
+                        return shiftsItem.class1TraysPerManHourExcludingDowntime;
+                      }();
+                    } else {
+                      shiftsItemObject.class1TraysPerManHourExcludingDowntime = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class2TraysPerHour' in shiftsItem) {
+                      shiftsItemObject.class2TraysPerHour = function () {
+                        if (typeof shiftsItem.class2TraysPerHour !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.class2TraysPerHour)) ? Number(shiftsItem.class2TraysPerHour) : Math.floor(Number(shiftsItem.class2TraysPerHour));
+                        }
+
+                        return Number.isInteger(shiftsItem.class2TraysPerHour) ? shiftsItem.class2TraysPerHour : Math.floor(shiftsItem.class2TraysPerHour);
+                      }();
+                    } else {
+                      shiftsItemObject.class2TraysPerHour = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class2TraysPerHourExcludingDowntime' in shiftsItem) {
+                      shiftsItemObject.class2TraysPerHourExcludingDowntime = function () {
+                        if (typeof shiftsItem.class2TraysPerHourExcludingDowntime !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.class2TraysPerHourExcludingDowntime)) ? Number(shiftsItem.class2TraysPerHourExcludingDowntime) : Math.floor(Number(shiftsItem.class2TraysPerHourExcludingDowntime));
+                        }
+
+                        return Number.isInteger(shiftsItem.class2TraysPerHourExcludingDowntime) ? shiftsItem.class2TraysPerHourExcludingDowntime : Math.floor(shiftsItem.class2TraysPerHourExcludingDowntime);
+                      }();
+                    } else {
+                      shiftsItemObject.class2TraysPerHourExcludingDowntime = 0;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class2TraysPerManHour' in shiftsItem) {
+                      shiftsItemObject.class2TraysPerManHour = function () {
+                        if (shiftsItem.class2TraysPerManHour === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class2TraysPerManHour !== 'number') {
+                          return Number(shiftsItem.class2TraysPerManHour);
+                        }
+
+                        return shiftsItem.class2TraysPerManHour;
+                      }();
+                    } else {
+                      shiftsItemObject.class2TraysPerManHour = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class2TraysPerManHourExcludingDowntime' in shiftsItem) {
+                      shiftsItemObject.class2TraysPerManHourExcludingDowntime = function () {
+                        if (shiftsItem.class2TraysPerManHourExcludingDowntime === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class2TraysPerManHourExcludingDowntime !== 'number') {
+                          return Number(shiftsItem.class2TraysPerManHourExcludingDowntime);
+                        }
+
+                        return shiftsItem.class2TraysPerManHourExcludingDowntime;
+                      }();
+                    } else {
+                      shiftsItemObject.class2TraysPerManHourExcludingDowntime = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1LayeredPercentageTarget' in shiftsItem) {
+                      shiftsItemObject.class1LayeredPercentageTarget = function () {
+                        if (shiftsItem.class1LayeredPercentageTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class1LayeredPercentageTarget !== 'number') {
+                          return Number(shiftsItem.class1LayeredPercentageTarget);
+                        }
+
+                        return shiftsItem.class1LayeredPercentageTarget;
+                      }();
+                    } else {
+                      shiftsItemObject.class1LayeredPercentageTarget = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1LayeredPercentage' in shiftsItem) {
+                      shiftsItemObject.class1LayeredPercentage = function () {
+                        if (shiftsItem.class1LayeredPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class1LayeredPercentage !== 'number') {
+                          return Number(shiftsItem.class1LayeredPercentage);
+                        }
+
+                        return shiftsItem.class1LayeredPercentage;
+                      }();
+                    } else {
+                      shiftsItemObject.class1LayeredPercentage = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'class1BulkPercentage' in shiftsItem) {
+                      shiftsItemObject.class1BulkPercentage = function () {
+                        if (shiftsItem.class1BulkPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.class1BulkPercentage !== 'number') {
+                          return Number(shiftsItem.class1BulkPercentage);
+                        }
+
+                        return shiftsItem.class1BulkPercentage;
+                      }();
+                    } else {
+                      shiftsItemObject.class1BulkPercentage = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'averageClass1Percentage' in shiftsItem) {
+                      shiftsItemObject.averageClass1Percentage = function () {
+                        if (shiftsItem.averageClass1Percentage === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.averageClass1Percentage !== 'number') {
+                          return Number(shiftsItem.averageClass1Percentage);
+                        }
+
+                        return shiftsItem.averageClass1Percentage;
+                      }();
+                    } else {
+                      shiftsItemObject.averageClass1Percentage = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'qualityR600IdealSamplesTarget' in shiftsItem) {
+                      shiftsItemObject.qualityR600IdealSamplesTarget = function () {
+                        if (shiftsItem.qualityR600IdealSamplesTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.qualityR600IdealSamplesTarget !== 'number') {
+                          return Number(shiftsItem.qualityR600IdealSamplesTarget);
+                        }
+
+                        return shiftsItem.qualityR600IdealSamplesTarget;
+                      }();
+                    } else {
+                      shiftsItemObject.qualityR600IdealSamplesTarget = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'qualityR600IdealSamplesActual' in shiftsItem) {
+                      shiftsItemObject.qualityR600IdealSamplesActual = function () {
+                        if (shiftsItem.qualityR600IdealSamplesActual === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.qualityR600IdealSamplesActual !== 'number') {
+                          return Number(shiftsItem.qualityR600IdealSamplesActual);
+                        }
+
+                        return shiftsItem.qualityR600IdealSamplesActual;
+                      }();
+                    } else {
+                      shiftsItemObject.qualityR600IdealSamplesActual = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'satisfactionRating' in shiftsItem) {
+                      shiftsItemObject.satisfactionRating = function () {
+                        if (shiftsItem.satisfactionRating === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.satisfactionRating !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.satisfactionRating)) ? Number(shiftsItem.satisfactionRating) : Math.floor(Number(shiftsItem.satisfactionRating));
+                        }
+
+                        return Number.isInteger(shiftsItem.satisfactionRating) ? shiftsItem.satisfactionRating : Math.floor(shiftsItem.satisfactionRating);
+                      }();
+                    } else {
+                      shiftsItemObject.satisfactionRating = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'keyCelebration' in shiftsItem) {
+                      shiftsItemObject.keyCelebration = function () {
+                        if (shiftsItem.keyCelebration === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.keyCelebration !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.keyCelebration)) ? Number(shiftsItem.keyCelebration) : Math.floor(Number(shiftsItem.keyCelebration));
+                        }
+
+                        return Number.isInteger(shiftsItem.keyCelebration) ? shiftsItem.keyCelebration : Math.floor(shiftsItem.keyCelebration);
+                      }();
+                    } else {
+                      shiftsItemObject.keyCelebration = null;
+                    }
+
+                    if (_typeof(shiftsItem) === 'object' && 'keyChallenge' in shiftsItem) {
+                      shiftsItemObject.keyChallenge = function () {
+                        if (shiftsItem.keyChallenge === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftsItem.keyChallenge !== 'number') {
+                          return Number.isInteger(Number(shiftsItem.keyChallenge)) ? Number(shiftsItem.keyChallenge) : Math.floor(Number(shiftsItem.keyChallenge));
+                        }
+
+                        return Number.isInteger(shiftsItem.keyChallenge) ? shiftsItem.keyChallenge : Math.floor(shiftsItem.keyChallenge);
+                      }();
+                    } else {
+                      shiftsItemObject.keyChallenge = null;
+                    }
+
+                    return shiftsItemObject;
+                  }();
+                });
+              }();
+            } else {
+              resultObject.shifts = [];
+            }
+
+            if (_typeof(result) === 'object' && 'shiftHourlyEntries' in result) {
+              resultObject.shiftHourlyEntries = function () {
+                if (Array.isArray(result.shiftHourlyEntries) !== true) {
+                  return [];
+                }
+
+                return result.shiftHourlyEntries.map(function (shiftHourlyEntriesItem) {
+                  return function () {
+                    var shiftHourlyEntriesItemObject = {};
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'siteId' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.siteId = function () {
+                        if (typeof shiftHourlyEntriesItem.siteId !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.siteId)) ? Number(shiftHourlyEntriesItem.siteId) : Math.floor(Number(shiftHourlyEntriesItem.siteId));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.siteId) ? shiftHourlyEntriesItem.siteId : Math.floor(shiftHourlyEntriesItem.siteId);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.siteId = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'siteName' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.siteName = function () {
+                        if (typeof shiftHourlyEntriesItem.siteName !== 'string') {
+                          return String(shiftHourlyEntriesItem.siteName);
+                        }
+
+                        return shiftHourlyEntriesItem.siteName;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.siteName = "";
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'packingLineId' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.packingLineId = function () {
+                        if (typeof shiftHourlyEntriesItem.packingLineId !== 'string') {
+                          return String(shiftHourlyEntriesItem.packingLineId);
+                        }
+
+                        return shiftHourlyEntriesItem.packingLineId;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.packingLineId = "";
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'packingLineName' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.packingLineName = function () {
+                        if (typeof shiftHourlyEntriesItem.packingLineName !== 'string') {
+                          return String(shiftHourlyEntriesItem.packingLineName);
+                        }
+
+                        return shiftHourlyEntriesItem.packingLineName;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.packingLineName = "";
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'shiftId' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.shiftId = function () {
+                        if (typeof shiftHourlyEntriesItem.shiftId !== 'string') {
+                          return String(shiftHourlyEntriesItem.shiftId);
+                        }
+
+                        return shiftHourlyEntriesItem.shiftId;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.shiftId = "";
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'shiftType' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.shiftType = function () {
+                        if (typeof shiftHourlyEntriesItem.shiftType !== 'string') {
+                          return String(shiftHourlyEntriesItem.shiftType);
+                        }
+
+                        return shiftHourlyEntriesItem.shiftType;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.shiftType = "";
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'isoWeek' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.isoWeek = function () {
+                        if (typeof shiftHourlyEntriesItem.isoWeek !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.isoWeek)) ? Number(shiftHourlyEntriesItem.isoWeek) : Math.floor(Number(shiftHourlyEntriesItem.isoWeek));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.isoWeek) ? shiftHourlyEntriesItem.isoWeek : Math.floor(shiftHourlyEntriesItem.isoWeek);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.isoWeek = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'startTimestamp' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.startTimestamp = function () {
+                        if (typeof shiftHourlyEntriesItem.startTimestamp !== 'string') {
+                          return new Date(String(shiftHourlyEntriesItem.startTimestamp));
+                        }
+
+                        return new Date(shiftHourlyEntriesItem.startTimestamp);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.startTimestamp = new Date();
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'endTimestamp' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.endTimestamp = function () {
+                        if (shiftHourlyEntriesItem.endTimestamp === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.endTimestamp !== 'string') {
+                          return new Date(String(shiftHourlyEntriesItem.endTimestamp));
+                        }
+
+                        return new Date(shiftHourlyEntriesItem.endTimestamp);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.endTimestamp = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'lineManagerName' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.lineManagerName = function () {
+                        if (shiftHourlyEntriesItem.lineManagerName === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.lineManagerName !== 'string') {
+                          return String(shiftHourlyEntriesItem.lineManagerName);
+                        }
+
+                        return shiftHourlyEntriesItem.lineManagerName;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.lineManagerName = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'qualityManagerName' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.qualityManagerName = function () {
+                        if (shiftHourlyEntriesItem.qualityManagerName === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.qualityManagerName !== 'string') {
+                          return String(shiftHourlyEntriesItem.qualityManagerName);
+                        }
+
+                        return shiftHourlyEntriesItem.qualityManagerName;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.qualityManagerName = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'varietyIds' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.varietyIds = function () {
+                        if (Array.isArray(shiftHourlyEntriesItem.varietyIds) !== true) {
+                          return [];
+                        }
+
+                        return shiftHourlyEntriesItem.varietyIds.map(function (varietyIdsItem) {
+                          return function () {
+                            if (typeof varietyIdsItem !== 'string') {
+                              return String(varietyIdsItem);
+                            }
+
+                            return varietyIdsItem;
+                          }();
+                        });
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.varietyIds = [];
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'varietyCodes' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.varietyCodes = function () {
+                        if (Array.isArray(shiftHourlyEntriesItem.varietyCodes) !== true) {
+                          return [];
+                        }
+
+                        return shiftHourlyEntriesItem.varietyCodes.map(function (varietyCodesItem) {
+                          return function () {
+                            if (typeof varietyCodesItem !== 'string') {
+                              return String(varietyCodesItem);
+                            }
+
+                            return varietyCodesItem;
+                          }();
+                        });
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.varietyCodes = [];
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'growingMethodIds' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.growingMethodIds = function () {
+                        if (Array.isArray(shiftHourlyEntriesItem.growingMethodIds) !== true) {
+                          return [];
+                        }
+
+                        return shiftHourlyEntriesItem.growingMethodIds.map(function (growingMethodIdsItem) {
+                          return function () {
+                            if (typeof growingMethodIdsItem !== 'string') {
+                              return String(growingMethodIdsItem);
+                            }
+
+                            return growingMethodIdsItem;
+                          }();
+                        });
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.growingMethodIds = [];
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'growingMethodCodes' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.growingMethodCodes = function () {
+                        if (Array.isArray(shiftHourlyEntriesItem.growingMethodCodes) !== true) {
+                          return [];
+                        }
+
+                        return shiftHourlyEntriesItem.growingMethodCodes.map(function (growingMethodCodesItem) {
+                          return function () {
+                            if (typeof growingMethodCodesItem !== 'string') {
+                              return String(growingMethodCodesItem);
+                            }
+
+                            return growingMethodCodesItem;
+                          }();
+                        });
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.growingMethodCodes = [];
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'totalBinsTipped' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.totalBinsTipped = function () {
+                        if (typeof shiftHourlyEntriesItem.totalBinsTipped !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.totalBinsTipped)) ? Number(shiftHourlyEntriesItem.totalBinsTipped) : Math.floor(Number(shiftHourlyEntriesItem.totalBinsTipped));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.totalBinsTipped) ? shiftHourlyEntriesItem.totalBinsTipped : Math.floor(shiftHourlyEntriesItem.totalBinsTipped);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.totalBinsTipped = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'totalProductionTime' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.totalProductionTime = function () {
+                        if (typeof shiftHourlyEntriesItem.totalProductionTime !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.totalProductionTime)) ? Number(shiftHourlyEntriesItem.totalProductionTime) : Math.floor(Number(shiftHourlyEntriesItem.totalProductionTime));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.totalProductionTime) ? shiftHourlyEntriesItem.totalProductionTime : Math.floor(shiftHourlyEntriesItem.totalProductionTime);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.totalProductionTime = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'totalScheduledBreakTime' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.totalScheduledBreakTime = function () {
+                        if (typeof shiftHourlyEntriesItem.totalScheduledBreakTime !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.totalScheduledBreakTime)) ? Number(shiftHourlyEntriesItem.totalScheduledBreakTime) : Math.floor(Number(shiftHourlyEntriesItem.totalScheduledBreakTime));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.totalScheduledBreakTime) ? shiftHourlyEntriesItem.totalScheduledBreakTime : Math.floor(shiftHourlyEntriesItem.totalScheduledBreakTime);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.totalScheduledBreakTime = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'totalDowntime' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.totalDowntime = function () {
+                        if (typeof shiftHourlyEntriesItem.totalDowntime !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.totalDowntime)) ? Number(shiftHourlyEntriesItem.totalDowntime) : Math.floor(Number(shiftHourlyEntriesItem.totalDowntime));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.totalDowntime) ? shiftHourlyEntriesItem.totalDowntime : Math.floor(shiftHourlyEntriesItem.totalDowntime);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.totalDowntime = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'downtimeEventsCount' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.downtimeEventsCount = function () {
+                        if (typeof shiftHourlyEntriesItem.downtimeEventsCount !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.downtimeEventsCount)) ? Number(shiftHourlyEntriesItem.downtimeEventsCount) : Math.floor(Number(shiftHourlyEntriesItem.downtimeEventsCount));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.downtimeEventsCount) ? shiftHourlyEntriesItem.downtimeEventsCount : Math.floor(shiftHourlyEntriesItem.downtimeEventsCount);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.downtimeEventsCount = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'downtimeEventsAverageDuration' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.downtimeEventsAverageDuration = function () {
+                        if (typeof shiftHourlyEntriesItem.downtimeEventsAverageDuration !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.downtimeEventsAverageDuration)) ? Number(shiftHourlyEntriesItem.downtimeEventsAverageDuration) : Math.floor(Number(shiftHourlyEntriesItem.downtimeEventsAverageDuration));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.downtimeEventsAverageDuration) ? shiftHourlyEntriesItem.downtimeEventsAverageDuration : Math.floor(shiftHourlyEntriesItem.downtimeEventsAverageDuration);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.downtimeEventsAverageDuration = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1ManningTarget' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1ManningTarget = function () {
+                        if (shiftHourlyEntriesItem.class1ManningTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class1ManningTarget !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.class1ManningTarget)) ? Number(shiftHourlyEntriesItem.class1ManningTarget) : Math.floor(Number(shiftHourlyEntriesItem.class1ManningTarget));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.class1ManningTarget) ? shiftHourlyEntriesItem.class1ManningTarget : Math.floor(shiftHourlyEntriesItem.class1ManningTarget);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1ManningTarget = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1Manning' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1Manning = function () {
+                        if (shiftHourlyEntriesItem.class1Manning === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class1Manning !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.class1Manning)) ? Number(shiftHourlyEntriesItem.class1Manning) : Math.floor(Number(shiftHourlyEntriesItem.class1Manning));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.class1Manning) ? shiftHourlyEntriesItem.class1Manning : Math.floor(shiftHourlyEntriesItem.class1Manning);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1Manning = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1ManningPercentage' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1ManningPercentage = function () {
+                        if (shiftHourlyEntriesItem.class1ManningPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class1ManningPercentage !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class1ManningPercentage);
+                        }
+
+                        return shiftHourlyEntriesItem.class1ManningPercentage;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1ManningPercentage = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class2ManningTarget' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class2ManningTarget = function () {
+                        if (shiftHourlyEntriesItem.class2ManningTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class2ManningTarget !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.class2ManningTarget)) ? Number(shiftHourlyEntriesItem.class2ManningTarget) : Math.floor(Number(shiftHourlyEntriesItem.class2ManningTarget));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.class2ManningTarget) ? shiftHourlyEntriesItem.class2ManningTarget : Math.floor(shiftHourlyEntriesItem.class2ManningTarget);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class2ManningTarget = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class2Manning' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class2Manning = function () {
+                        if (shiftHourlyEntriesItem.class2Manning === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class2Manning !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.class2Manning)) ? Number(shiftHourlyEntriesItem.class2Manning) : Math.floor(Number(shiftHourlyEntriesItem.class2Manning));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.class2Manning) ? shiftHourlyEntriesItem.class2Manning : Math.floor(shiftHourlyEntriesItem.class2Manning);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class2Manning = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class2ManningPercentage' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class2ManningPercentage = function () {
+                        if (shiftHourlyEntriesItem.class2ManningPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class2ManningPercentage !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class2ManningPercentage);
+                        }
+
+                        return shiftHourlyEntriesItem.class2ManningPercentage;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class2ManningPercentage = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'totalManningTarget' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.totalManningTarget = function () {
+                        if (shiftHourlyEntriesItem.totalManningTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.totalManningTarget !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.totalManningTarget)) ? Number(shiftHourlyEntriesItem.totalManningTarget) : Math.floor(Number(shiftHourlyEntriesItem.totalManningTarget));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.totalManningTarget) ? shiftHourlyEntriesItem.totalManningTarget : Math.floor(shiftHourlyEntriesItem.totalManningTarget);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.totalManningTarget = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'totalManning' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.totalManning = function () {
+                        if (shiftHourlyEntriesItem.totalManning === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.totalManning !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.totalManning)) ? Number(shiftHourlyEntriesItem.totalManning) : Math.floor(Number(shiftHourlyEntriesItem.totalManning));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.totalManning) ? shiftHourlyEntriesItem.totalManning : Math.floor(shiftHourlyEntriesItem.totalManning);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.totalManning = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'totalManningPercentage' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.totalManningPercentage = function () {
+                        if (shiftHourlyEntriesItem.totalManningPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.totalManningPercentage !== 'number') {
+                          return Number(shiftHourlyEntriesItem.totalManningPercentage);
+                        }
+
+                        return shiftHourlyEntriesItem.totalManningPercentage;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.totalManningPercentage = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'costPerManningUnitHour' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.costPerManningUnitHour = function () {
+                        if (shiftHourlyEntriesItem.costPerManningUnitHour === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.costPerManningUnitHour !== 'number') {
+                          return Number(shiftHourlyEntriesItem.costPerManningUnitHour);
+                        }
+
+                        return shiftHourlyEntriesItem.costPerManningUnitHour;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.costPerManningUnitHour = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'totalMinutesWorked' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.totalMinutesWorked = function () {
+                        if (typeof shiftHourlyEntriesItem.totalMinutesWorked !== 'number') {
+                          return Number(shiftHourlyEntriesItem.totalMinutesWorked);
+                        }
+
+                        return shiftHourlyEntriesItem.totalMinutesWorked;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.totalMinutesWorked = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'totalMinutesWorkedExcludingDowntime' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.totalMinutesWorkedExcludingDowntime = function () {
+                        if (typeof shiftHourlyEntriesItem.totalMinutesWorkedExcludingDowntime !== 'number') {
+                          return Number(shiftHourlyEntriesItem.totalMinutesWorkedExcludingDowntime);
+                        }
+
+                        return shiftHourlyEntriesItem.totalMinutesWorkedExcludingDowntime;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.totalMinutesWorkedExcludingDowntime = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'totalMinutesPaid' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.totalMinutesPaid = function () {
+                        if (typeof shiftHourlyEntriesItem.totalMinutesPaid !== 'number') {
+                          return Number(shiftHourlyEntriesItem.totalMinutesPaid);
+                        }
+
+                        return shiftHourlyEntriesItem.totalMinutesPaid;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.totalMinutesPaid = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1TotalManningCost' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1TotalManningCost = function () {
+                        if (shiftHourlyEntriesItem.class1TotalManningCost === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class1TotalManningCost !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class1TotalManningCost);
+                        }
+
+                        return shiftHourlyEntriesItem.class1TotalManningCost;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1TotalManningCost = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class2TotalManningCost' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class2TotalManningCost = function () {
+                        if (shiftHourlyEntriesItem.class2TotalManningCost === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class2TotalManningCost !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class2TotalManningCost);
+                        }
+
+                        return shiftHourlyEntriesItem.class2TotalManningCost;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class2TotalManningCost = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1DowntimeManningCost' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1DowntimeManningCost = function () {
+                        if (shiftHourlyEntriesItem.class1DowntimeManningCost === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class1DowntimeManningCost !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class1DowntimeManningCost);
+                        }
+
+                        return shiftHourlyEntriesItem.class1DowntimeManningCost;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1DowntimeManningCost = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class2DowntimeManningCost' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class2DowntimeManningCost = function () {
+                        if (shiftHourlyEntriesItem.class2DowntimeManningCost === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class2DowntimeManningCost !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class2DowntimeManningCost);
+                        }
+
+                        return shiftHourlyEntriesItem.class2DowntimeManningCost;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class2DowntimeManningCost = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1CostPerTrayTarget' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1CostPerTrayTarget = function () {
+                        if (shiftHourlyEntriesItem.class1CostPerTrayTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class1CostPerTrayTarget !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class1CostPerTrayTarget);
+                        }
+
+                        return shiftHourlyEntriesItem.class1CostPerTrayTarget;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1CostPerTrayTarget = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1CostPerTrayActual' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1CostPerTrayActual = function () {
+                        if (shiftHourlyEntriesItem.class1CostPerTrayActual === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class1CostPerTrayActual !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class1CostPerTrayActual);
+                        }
+
+                        return shiftHourlyEntriesItem.class1CostPerTrayActual;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1CostPerTrayActual = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class2CostPerTrayActual' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class2CostPerTrayActual = function () {
+                        if (shiftHourlyEntriesItem.class2CostPerTrayActual === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class2CostPerTrayActual !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class2CostPerTrayActual);
+                        }
+
+                        return shiftHourlyEntriesItem.class2CostPerTrayActual;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class2CostPerTrayActual = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'totalClass1Trays' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.totalClass1Trays = function () {
+                        if (typeof shiftHourlyEntriesItem.totalClass1Trays !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.totalClass1Trays)) ? Number(shiftHourlyEntriesItem.totalClass1Trays) : Math.floor(Number(shiftHourlyEntriesItem.totalClass1Trays));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.totalClass1Trays) ? shiftHourlyEntriesItem.totalClass1Trays : Math.floor(shiftHourlyEntriesItem.totalClass1Trays);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.totalClass1Trays = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'totalClass2Trays' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.totalClass2Trays = function () {
+                        if (typeof shiftHourlyEntriesItem.totalClass2Trays !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.totalClass2Trays)) ? Number(shiftHourlyEntriesItem.totalClass2Trays) : Math.floor(Number(shiftHourlyEntriesItem.totalClass2Trays));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.totalClass2Trays) ? shiftHourlyEntriesItem.totalClass2Trays : Math.floor(shiftHourlyEntriesItem.totalClass2Trays);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.totalClass2Trays = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1TraysPerHourExcludingDowntime' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1TraysPerHourExcludingDowntime = function () {
+                        if (typeof shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntime !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntime)) ? Number(shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntime) : Math.floor(Number(shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntime));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntime) ? shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntime : Math.floor(shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntime);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1TraysPerHourExcludingDowntime = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1TraysPerHourExcludingDowntimeTarget' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1TraysPerHourExcludingDowntimeTarget = function () {
+                        if (typeof shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntimeTarget !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntimeTarget)) ? Number(shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntimeTarget) : Math.floor(Number(shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntimeTarget));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntimeTarget) ? shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntimeTarget : Math.floor(shiftHourlyEntriesItem.class1TraysPerHourExcludingDowntimeTarget);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1TraysPerHourExcludingDowntimeTarget = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1TraysPerManHourExcludingDowntime' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1TraysPerManHourExcludingDowntime = function () {
+                        if (shiftHourlyEntriesItem.class1TraysPerManHourExcludingDowntime === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class1TraysPerManHourExcludingDowntime !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class1TraysPerManHourExcludingDowntime);
+                        }
+
+                        return shiftHourlyEntriesItem.class1TraysPerManHourExcludingDowntime;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1TraysPerManHourExcludingDowntime = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class2TraysPerHourExcludingDowntime' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class2TraysPerHourExcludingDowntime = function () {
+                        if (typeof shiftHourlyEntriesItem.class2TraysPerHourExcludingDowntime !== 'number') {
+                          return Number.isInteger(Number(shiftHourlyEntriesItem.class2TraysPerHourExcludingDowntime)) ? Number(shiftHourlyEntriesItem.class2TraysPerHourExcludingDowntime) : Math.floor(Number(shiftHourlyEntriesItem.class2TraysPerHourExcludingDowntime));
+                        }
+
+                        return Number.isInteger(shiftHourlyEntriesItem.class2TraysPerHourExcludingDowntime) ? shiftHourlyEntriesItem.class2TraysPerHourExcludingDowntime : Math.floor(shiftHourlyEntriesItem.class2TraysPerHourExcludingDowntime);
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class2TraysPerHourExcludingDowntime = 0;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class2TraysPerManHourExcludingDowntime' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class2TraysPerManHourExcludingDowntime = function () {
+                        if (shiftHourlyEntriesItem.class2TraysPerManHourExcludingDowntime === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class2TraysPerManHourExcludingDowntime !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class2TraysPerManHourExcludingDowntime);
+                        }
+
+                        return shiftHourlyEntriesItem.class2TraysPerManHourExcludingDowntime;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class2TraysPerManHourExcludingDowntime = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1LayeredPercentageTarget' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1LayeredPercentageTarget = function () {
+                        if (shiftHourlyEntriesItem.class1LayeredPercentageTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class1LayeredPercentageTarget !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class1LayeredPercentageTarget);
+                        }
+
+                        return shiftHourlyEntriesItem.class1LayeredPercentageTarget;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1LayeredPercentageTarget = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1LayeredPercentage' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1LayeredPercentage = function () {
+                        if (shiftHourlyEntriesItem.class1LayeredPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class1LayeredPercentage !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class1LayeredPercentage);
+                        }
+
+                        return shiftHourlyEntriesItem.class1LayeredPercentage;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1LayeredPercentage = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'class1BulkPercentage' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.class1BulkPercentage = function () {
+                        if (shiftHourlyEntriesItem.class1BulkPercentage === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.class1BulkPercentage !== 'number') {
+                          return Number(shiftHourlyEntriesItem.class1BulkPercentage);
+                        }
+
+                        return shiftHourlyEntriesItem.class1BulkPercentage;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.class1BulkPercentage = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'averageClass1Percentage' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.averageClass1Percentage = function () {
+                        if (shiftHourlyEntriesItem.averageClass1Percentage === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.averageClass1Percentage !== 'number') {
+                          return Number(shiftHourlyEntriesItem.averageClass1Percentage);
+                        }
+
+                        return shiftHourlyEntriesItem.averageClass1Percentage;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.averageClass1Percentage = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'qualityR600IdealSamplesTarget' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.qualityR600IdealSamplesTarget = function () {
+                        if (shiftHourlyEntriesItem.qualityR600IdealSamplesTarget === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.qualityR600IdealSamplesTarget !== 'number') {
+                          return Number(shiftHourlyEntriesItem.qualityR600IdealSamplesTarget);
+                        }
+
+                        return shiftHourlyEntriesItem.qualityR600IdealSamplesTarget;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.qualityR600IdealSamplesTarget = null;
+                    }
+
+                    if (_typeof(shiftHourlyEntriesItem) === 'object' && 'qualityR600IdealSamplesActual' in shiftHourlyEntriesItem) {
+                      shiftHourlyEntriesItemObject.qualityR600IdealSamplesActual = function () {
+                        if (shiftHourlyEntriesItem.qualityR600IdealSamplesActual === null) {
+                          return null;
+                        }
+
+                        if (typeof shiftHourlyEntriesItem.qualityR600IdealSamplesActual !== 'number') {
+                          return Number(shiftHourlyEntriesItem.qualityR600IdealSamplesActual);
+                        }
+
+                        return shiftHourlyEntriesItem.qualityR600IdealSamplesActual;
+                      }();
+                    } else {
+                      shiftHourlyEntriesItemObject.qualityR600IdealSamplesActual = null;
+                    }
+
+                    return shiftHourlyEntriesItemObject;
+                  }();
+                });
+              }();
+            } else {
+              resultObject.shiftHourlyEntries = [];
+            }
+
+            if (_typeof(result) === 'object' && 'downtimeEvents' in result) {
+              resultObject.downtimeEvents = function () {
+                if (Array.isArray(result.downtimeEvents) !== true) {
+                  return [];
+                }
+
+                return result.downtimeEvents.map(function (downtimeEventsItem) {
+                  return function () {
+                    var downtimeEventsItemObject = {};
+
+                    if (_typeof(downtimeEventsItem) === 'object' && 'siteId' in downtimeEventsItem) {
+                      downtimeEventsItemObject.siteId = function () {
+                        if (typeof downtimeEventsItem.siteId !== 'number') {
+                          return Number.isInteger(Number(downtimeEventsItem.siteId)) ? Number(downtimeEventsItem.siteId) : Math.floor(Number(downtimeEventsItem.siteId));
+                        }
+
+                        return Number.isInteger(downtimeEventsItem.siteId) ? downtimeEventsItem.siteId : Math.floor(downtimeEventsItem.siteId);
+                      }();
+                    } else {
+                      downtimeEventsItemObject.siteId = 0;
+                    }
+
+                    if (_typeof(downtimeEventsItem) === 'object' && 'siteName' in downtimeEventsItem) {
+                      downtimeEventsItemObject.siteName = function () {
+                        if (typeof downtimeEventsItem.siteName !== 'string') {
+                          return String(downtimeEventsItem.siteName);
+                        }
+
+                        return downtimeEventsItem.siteName;
+                      }();
+                    } else {
+                      downtimeEventsItemObject.siteName = "";
+                    }
+
+                    if (_typeof(downtimeEventsItem) === 'object' && 'packingLineId' in downtimeEventsItem) {
+                      downtimeEventsItemObject.packingLineId = function () {
+                        if (typeof downtimeEventsItem.packingLineId !== 'string') {
+                          return String(downtimeEventsItem.packingLineId);
+                        }
+
+                        return downtimeEventsItem.packingLineId;
+                      }();
+                    } else {
+                      downtimeEventsItemObject.packingLineId = "";
+                    }
+
+                    if (_typeof(downtimeEventsItem) === 'object' && 'packingLineName' in downtimeEventsItem) {
+                      downtimeEventsItemObject.packingLineName = function () {
+                        if (typeof downtimeEventsItem.packingLineName !== 'string') {
+                          return String(downtimeEventsItem.packingLineName);
+                        }
+
+                        return downtimeEventsItem.packingLineName;
+                      }();
+                    } else {
+                      downtimeEventsItemObject.packingLineName = "";
+                    }
+
+                    if (_typeof(downtimeEventsItem) === 'object' && 'shiftId' in downtimeEventsItem) {
+                      downtimeEventsItemObject.shiftId = function () {
+                        if (typeof downtimeEventsItem.shiftId !== 'string') {
+                          return String(downtimeEventsItem.shiftId);
+                        }
+
+                        return downtimeEventsItem.shiftId;
+                      }();
+                    } else {
+                      downtimeEventsItemObject.shiftId = "";
+                    }
+
+                    if (_typeof(downtimeEventsItem) === 'object' && 'shiftType' in downtimeEventsItem) {
+                      downtimeEventsItemObject.shiftType = function () {
+                        if (typeof downtimeEventsItem.shiftType !== 'string') {
+                          return String(downtimeEventsItem.shiftType);
+                        }
+
+                        return downtimeEventsItem.shiftType;
+                      }();
+                    } else {
+                      downtimeEventsItemObject.shiftType = "";
+                    }
+
+                    if (_typeof(downtimeEventsItem) === 'object' && 'isoWeek' in downtimeEventsItem) {
+                      downtimeEventsItemObject.isoWeek = function () {
+                        if (typeof downtimeEventsItem.isoWeek !== 'number') {
+                          return Number.isInteger(Number(downtimeEventsItem.isoWeek)) ? Number(downtimeEventsItem.isoWeek) : Math.floor(Number(downtimeEventsItem.isoWeek));
+                        }
+
+                        return Number.isInteger(downtimeEventsItem.isoWeek) ? downtimeEventsItem.isoWeek : Math.floor(downtimeEventsItem.isoWeek);
+                      }();
+                    } else {
+                      downtimeEventsItemObject.isoWeek = 0;
+                    }
+
+                    if (_typeof(downtimeEventsItem) === 'object' && 'startTimestamp' in downtimeEventsItem) {
+                      downtimeEventsItemObject.startTimestamp = function () {
+                        if (typeof downtimeEventsItem.startTimestamp !== 'string') {
+                          return new Date(String(downtimeEventsItem.startTimestamp));
+                        }
+
+                        return new Date(downtimeEventsItem.startTimestamp);
+                      }();
+                    } else {
+                      downtimeEventsItemObject.startTimestamp = new Date();
+                    }
+
+                    if (_typeof(downtimeEventsItem) === 'object' && 'endTimestamp' in downtimeEventsItem) {
+                      downtimeEventsItemObject.endTimestamp = function () {
+                        if (downtimeEventsItem.endTimestamp === null) {
+                          return null;
+                        }
+
+                        if (typeof downtimeEventsItem.endTimestamp !== 'string') {
+                          return new Date(String(downtimeEventsItem.endTimestamp));
+                        }
+
+                        return new Date(downtimeEventsItem.endTimestamp);
+                      }();
+                    } else {
+                      downtimeEventsItemObject.endTimestamp = null;
+                    }
+
+                    if (_typeof(downtimeEventsItem) === 'object' && 'reasonCategory' in downtimeEventsItem) {
+                      downtimeEventsItemObject.reasonCategory = function () {
+                        if (downtimeEventsItem.reasonCategory === null) {
+                          return null;
+                        }
+
+                        if (typeof downtimeEventsItem.reasonCategory !== 'string') {
+                          return String(downtimeEventsItem.reasonCategory);
+                        }
+
+                        return downtimeEventsItem.reasonCategory;
+                      }();
+                    } else {
+                      downtimeEventsItemObject.reasonCategory = null;
+                    }
+
+                    if (_typeof(downtimeEventsItem) === 'object' && 'reasonTag' in downtimeEventsItem) {
+                      downtimeEventsItemObject.reasonTag = function () {
+                        if (downtimeEventsItem.reasonTag === null) {
+                          return null;
+                        }
+
+                        if (typeof downtimeEventsItem.reasonTag !== 'string') {
+                          return String(downtimeEventsItem.reasonTag);
+                        }
+
+                        return downtimeEventsItem.reasonTag;
+                      }();
+                    } else {
+                      downtimeEventsItemObject.reasonTag = null;
+                    }
+
+                    if (_typeof(downtimeEventsItem) === 'object' && 'remedyAction' in downtimeEventsItem) {
+                      downtimeEventsItemObject.remedyAction = function () {
+                        if (downtimeEventsItem.remedyAction === null) {
+                          return null;
+                        }
+
+                        if (typeof downtimeEventsItem.remedyAction !== 'string') {
+                          return String(downtimeEventsItem.remedyAction);
+                        }
+
+                        return downtimeEventsItem.remedyAction;
+                      }();
+                    } else {
+                      downtimeEventsItemObject.remedyAction = null;
+                    }
+
+                    return downtimeEventsItemObject;
+                  }();
+                });
+              }();
+            } else {
+              resultObject.downtimeEvents = [];
+            }
+
+            if (_typeof(result) === 'object' && 'packagingConsumption' in result) {
+              resultObject.packagingConsumption = function () {
+                if (Array.isArray(result.packagingConsumption) !== true) {
+                  return [];
+                }
+
+                return result.packagingConsumption.map(function (packagingConsumptionItem) {
+                  return function () {
+                    var packagingConsumptionItemObject = {};
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'siteId' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.siteId = function () {
+                        if (typeof packagingConsumptionItem.siteId !== 'number') {
+                          return Number.isInteger(Number(packagingConsumptionItem.siteId)) ? Number(packagingConsumptionItem.siteId) : Math.floor(Number(packagingConsumptionItem.siteId));
+                        }
+
+                        return Number.isInteger(packagingConsumptionItem.siteId) ? packagingConsumptionItem.siteId : Math.floor(packagingConsumptionItem.siteId);
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.siteId = 0;
+                    }
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'siteName' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.siteName = function () {
+                        if (typeof packagingConsumptionItem.siteName !== 'string') {
+                          return String(packagingConsumptionItem.siteName);
+                        }
+
+                        return packagingConsumptionItem.siteName;
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.siteName = "";
+                    }
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'packingLineId' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.packingLineId = function () {
+                        if (typeof packagingConsumptionItem.packingLineId !== 'string') {
+                          return String(packagingConsumptionItem.packingLineId);
+                        }
+
+                        return packagingConsumptionItem.packingLineId;
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.packingLineId = "";
+                    }
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'packingLineName' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.packingLineName = function () {
+                        if (typeof packagingConsumptionItem.packingLineName !== 'string') {
+                          return String(packagingConsumptionItem.packingLineName);
+                        }
+
+                        return packagingConsumptionItem.packingLineName;
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.packingLineName = "";
+                    }
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'packrunId' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.packrunId = function () {
+                        if (typeof packagingConsumptionItem.packrunId !== 'string') {
+                          return String(packagingConsumptionItem.packrunId);
+                        }
+
+                        return packagingConsumptionItem.packrunId;
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.packrunId = "";
+                    }
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'packrunName' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.packrunName = function () {
+                        if (typeof packagingConsumptionItem.packrunName !== 'string') {
+                          return String(packagingConsumptionItem.packrunName);
+                        }
+
+                        return packagingConsumptionItem.packrunName;
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.packrunName = "";
+                    }
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'varietyId' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.varietyId = function () {
+                        if (typeof packagingConsumptionItem.varietyId !== 'string') {
+                          return String(packagingConsumptionItem.varietyId);
+                        }
+
+                        return packagingConsumptionItem.varietyId;
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.varietyId = "";
+                    }
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'varietyCode' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.varietyCode = function () {
+                        if (typeof packagingConsumptionItem.varietyCode !== 'string') {
+                          return String(packagingConsumptionItem.varietyCode);
+                        }
+
+                        return packagingConsumptionItem.varietyCode;
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.varietyCode = "";
+                    }
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'isoWeek' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.isoWeek = function () {
+                        if (typeof packagingConsumptionItem.isoWeek !== 'number') {
+                          return Number.isInteger(Number(packagingConsumptionItem.isoWeek)) ? Number(packagingConsumptionItem.isoWeek) : Math.floor(Number(packagingConsumptionItem.isoWeek));
+                        }
+
+                        return Number.isInteger(packagingConsumptionItem.isoWeek) ? packagingConsumptionItem.isoWeek : Math.floor(packagingConsumptionItem.isoWeek);
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.isoWeek = 0;
+                    }
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'startTimestamp' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.startTimestamp = function () {
+                        if (typeof packagingConsumptionItem.startTimestamp !== 'string') {
+                          return new Date(String(packagingConsumptionItem.startTimestamp));
+                        }
+
+                        return new Date(packagingConsumptionItem.startTimestamp);
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.startTimestamp = new Date();
+                    }
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'endTimestamp' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.endTimestamp = function () {
+                        if (packagingConsumptionItem.endTimestamp === null) {
+                          return null;
+                        }
+
+                        if (typeof packagingConsumptionItem.endTimestamp !== 'string') {
+                          return new Date(String(packagingConsumptionItem.endTimestamp));
+                        }
+
+                        return new Date(packagingConsumptionItem.endTimestamp);
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.endTimestamp = null;
+                    }
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'packType' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.packType = function () {
+                        if (typeof packagingConsumptionItem.packType !== 'string') {
+                          return String(packagingConsumptionItem.packType);
+                        }
+
+                        return packagingConsumptionItem.packType;
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.packType = "";
+                    }
+
+                    if (_typeof(packagingConsumptionItem) === 'object' && 'quantity' in packagingConsumptionItem) {
+                      packagingConsumptionItemObject.quantity = function () {
+                        if (typeof packagingConsumptionItem.quantity !== 'number') {
+                          return Number.isInteger(Number(packagingConsumptionItem.quantity)) ? Number(packagingConsumptionItem.quantity) : Math.floor(Number(packagingConsumptionItem.quantity));
+                        }
+
+                        return Number.isInteger(packagingConsumptionItem.quantity) ? packagingConsumptionItem.quantity : Math.floor(packagingConsumptionItem.quantity);
+                      }();
+                    } else {
+                      packagingConsumptionItemObject.quantity = 0;
+                    }
+
+                    return packagingConsumptionItemObject;
+                  }();
+                });
+              }();
+            } else {
+              resultObject.packagingConsumption = [];
+            }
+
+            return resultObject;
+          }();
+
+          resolve(resolveValue);
+        }).catch(function (error) {
+          return reject(error);
+        });
+      });
+    }
+    /**
+     * Retrieve Production Data as an Excel Spreadsheet [GET /packhouse/production-data-export/excel]
+     * 
+     * Request a Production Data Export in the form of an Excel Spreadsheet
+     * 
+     * @static
+     * @public
+     * @return {Promise<boolean>}
+     */
+
+  }, {
+    key: "excelExport",
+    value: function excelExport() {
+      return new Promise(function (resolve, reject) {
+        _RequestHelper.default.getRequest("/packhouse/production-data-export/excel").then(function (result) {
+          resolve(result !== null && result !== void 0 ? result : true);
+        }).catch(function (error) {
+          return reject(error);
+        });
+      });
+    }
+    /**
+     * Retrieve Production Data as a CSV File [GET /packhouse/production-data-export/csv]
+     * 
+     * Request a Production Data Export in the form of a CSV File
+     * 
+     * @static
+     * @public
+     * @return {Promise<boolean>}
+     */
+
+  }, {
+    key: "csvExport",
+    value: function csvExport() {
+      return new Promise(function (resolve, reject) {
+        _RequestHelper.default.getRequest("/packhouse/production-data-export/csv").then(function (result) {
+          resolve(result !== null && result !== void 0 ? result : true);
+        }).catch(function (error) {
+          return reject(error);
+        });
+      });
+    }
+  }]);
+
+  return ProductionDataExportController;
+}();
+
+var _default = ProductionDataExportController;
+/**
+ * The Optional Query Parameters for the jsonExport Function
+ * 
+ * @typedef {Object} ProductionDataExportController.JsonExportQueryParameters
+ * @property {number[]} [siteIds] A List of Site IDs to Filter by
+ * @property {string[]} [packingLineIds] A List of Packing Line IDs to Filter by
+ * @memberof Controllers.Packhouse
+ */
+
+/**
+ * A **PackrunData** Type
+ * 
+ * @typedef {Object} ProductionDataExportController.PackrunData
+ * @property {number} siteId ID of the Site where this Packrun occurred
+ * @property {string} siteName Name of the Site where this Packrun occurred
+ * @property {string} packingLineId ID of the Packing Line where this Packrun occurred
+ * @property {string} packingLineName Name of the Packing Line where this Packrun occurred
+ * @property {number} isoWeek ISO Week when this Packrun occurred
+ * @property {Date} startTimestamp Timestamp when this Packrun was Started
+ * @property {?Date} finishTimestamp Timestamp when this Packrun was Finished
+ * @property {string} packrunId ID of the Packrun
+ * @property {string} packrunName Name of the Packrun
+ * @property {string} varietyId ID of the Variety associated with this Packrun
+ * @property {string} varietyCode Code of the Variety associated with this Packrun
+ * @property {string} growingMethodId ID of the Growing Method associated with this Packrun
+ * @property {string} growingMethodCode Code of the Growing Method associated with this Packrun
+ * @property {string} growerCode Grower Code of the Packrun
+ * @property {string} growerName Grower Name of the Packrun
+ * @property {string} maturityArea Maturity Area of the Packrun
+ * @property {number} allocatedBins Number of Bins Allocated to this Packrun
+ * @property {number} totalBinsTipped Number of Bins Tipped during this Packrun
+ * @property {number} totalNetWeightTipped Total Net Fruit Weight Tipped during this Packrun
+ * @property {number} averageNetWeightPerBin Average Net Fruit Weight per Bin for this Packrun
+ * @property {number} averageBinsTippedPerHour Average Bins Tipped per Hour during this Packrun
+ * @property {number} averageTimePerTippedBin Average Time Taken in Seconds to Tip a Bin during this Packrun
+ * @property {number} averageBinTipWeightThroughput Average Throughput in Kilograms per Hour for the Bin Tip during this Packrun
+ * @property {number} softSortEventsPerBin Number of Soft-Sort Events per Bin Tipped during this Packrun
+ * @property {number} totalSoftSortEventsCount Total Number of Soft-Sort Events that occurred during this Packrun
+ * @property {number} averageSoftSortEventsDuration Average Duration in Seconds of a Soft-Sort Event during this Packrun
+ * @property {number} totalSoftSortEventsDuration Total Duration in Seconds of all Soft-Sort Events that occurred during this Packrun
+ * @property {?boolean} softSortEventsAccurate Whether the Soft-Sort Events for this Packrun were Accurate according to the Line Manager
+ * @property {?string} softSortEventsNotAccurateReason A Reason for why the Soft-Sort Events were not Accurate
+ * @property {number} class1Percentage Class 1 Percentage for this Packrun
+ * @property {number} class2Percentage Class 2 Percentage for this Packrun
+ * @property {number} class3Percentage Class 3 Percentage for this Packrun
+ * @property {number} nssPercentage Non-Standard Supply Percentage for this Packrun
+ * @property {number} undersizePercentage Undersize Percentage for this Packrun
+ * @property {number} cdmPercentage Culled / Low Dry Matter Percentage for this Packrun
+ * @property {number} wastePercentage Waste Percentage for this Packrun
+ * @property {number} softSortPercentage Soft-Sort Percentage for this Packrun
+ * @property {number} totalNonClass1Percentage Total Non-Class 1 Percentage for this Packrun
+ * @property {number} class1Weight Total Class 1 Weight in Kilograms for this Packrun
+ * @property {number} class2Weight Total Class 2 Weight in Kilograms for this Packrun
+ * @property {number} class3Weight Total Class 3 Weight in Kilograms for this Packrun
+ * @property {number} nssWeight Total Non-Standard Supply Weight in Kilograms for this Packrun
+ * @property {number} undersizeWeight Total Undersize Weight in Kilograms for this Packrun
+ * @property {number} cdmWeight Total Culled / Low Dry Matter Weight in Kilograms for this Packrun
+ * @property {number} wasteWeight Total Waste Weight in Kilograms for this Packrun
+ * @property {number} softSortWeight Total Soft-Sort Weight in Kilograms for this Packrun
+ * @property {number} totalNonClass1Weight Total Non-Class 1 Weight in Kilograms for this Packrun
+ * @property {number} totalClass1Trays Total Class 1 Tray Equivalents Produced during this Packrun
+ * @property {number} totalClass2Trays Total Class 2 Tray Equivalents Produced during this Packrun
+ * @property {number} totalClass1FruitCount Total Number of Class 1 Fruit that were Packed during this Packrun
+ * @property {number} totalClass2FruitCount Total Number of Class 2 Fruit that were Packed during this Packrun
+ * @property {number} averageClass1TrayWeight Average Class 1 Tray Equivalent Weight in Kilograms for this Packrun
+ * @property {number} averageClass2TrayWeight Average Class 2 Tray Equivalent Weight in Kilograms for this Packrun
+ * @property {number} class1TraysPerBin Average Class 1 Trays Produced per Bin Tipped for this Packrun
+ * @property {number} averageFruitSize Average Fruit Size for this Packrun
+ * @property {number} averageFruitWeight Average Fruit Weight in Grams for this Packrun
+ * @property {number} totalRejectBinsCount Total Number of Reject Bins Weighed during this Packrun
+ * @property {number} totalRejectBinsNetWeight Total Net Fruit Weight in Kilograms captured in Reject Bins during this Packrun
+ * @property {?number} qualityR600TotalFruitSampled Total Number of R600 Class 1 Fruit Sampled by Quality Control during this Packrun
+ * @property {?number} qualityR600FruitSampledPercentage Percentage of R600 Class 1 Fruit Sampled by Quality Control during this Packrun
+ * @property {?number} qualityR600AverageSampledFruitSize Average R600 Class 1 Fruit Size that was Sampled by Quality Control during this Packrun
+ * @property {?number} qualityR600TotalSamplesCount Total Number of Class 1 R600 Samples Collected by Quality Control during this Packrun
+ * @property {?number} qualityR600IdealSamplesTarget Target Percentage of R600 Samples that should be in the Ideal Range for this Packrun
+ * @property {?number} qualityR600IdealSamplesActual Actual Percentage of R600 Samples that were in the Ideal Range during this Packrun
+ * @property {?number} qualityR600MinorPackingDefects Percentage of Minor Packing Defects found in Class 1 R600 Samples during this Packrun
+ * @property {?number} qualityR600MajorPackingDefects Percentage of Major Packing Defects found in Class 1 R600 Samples during this Packrun
+ * @property {?number} qualityR600Softs Percentage of Soft Fruit found in Class 1 R600 Samples during this Packrun
+ * @property {?number} qualityR600Cuts Percentage of Cut (Flesh Damaged) Fruit found in Class 1 R600 Samples during this Packrun
+ * @property {?number} qualityR600Rots Percentage of Rotten Fruit found in Class 1 R600 Samples during this Packrun
+ * @property {?number} qualityExportFruitInClass2 Percentage of Export Fruit found in Class 2 during this Packrun
+ * @property {?number} qualityExportFruitInClass3 Percentage of Export Fruit found in Class 3 during this Packrun
+ * @property {?number} qualityExportFruitInWaste Percentage of Export Fruit found in Waste during this Packrun
+ * @property {string[]} shiftIds An Array of Shift IDs this Packrun is associated with
+ * @property {string[]} shiftTypes An Array of Shift Types that were encountered during this Packrun
+ * @property {string[]} lineManagerNames An Array of Line Managers who were involved with this Packrun
+ * @property {string[]} qualityManagerNames An Array of Quality Managers who were involved with this Packrun
+ * @property {number} totalProductionTime Total Shift Production Time in Seconds for this Packrun
+ * @property {number} totalScheduledBreakTime Total Shift Scheduled Break Time in Seconds for this Packrun
+ * @property {number} totalDowntime Total Shift Downtime in Seconds for this Packrun
+ * @property {number} downtimeEventsCount Number of Downtime Events that occurred during this Packrun
+ * @property {number} downtimeEventsAverageDuration Average Duration in Seconds of a Downtime Event during this Packrun
+ * @property {?number} class1ManningTarget Target Number of People working on the Packing Line (excluding Class 2) during this Packrun
+ * @property {?number} averageClass1Manning Average Number of People working on the Packing Line (excluding Class 2) during this Packrun
+ * @property {?number} class1ManningPercentage Percentage of Target vs Actual Number of People working on the Packing Line (excluding Class 2) during this Packrun
+ * @property {?number} class2ManningTarget Target Number of People working in the Class 2 area of the Packing Line during this Packrun
+ * @property {?number} averageClass2Manning Average Number of People working in the Class 2 area of the Packing Line during this Packrun
+ * @property {?number} class2ManningPercentage Percentage of Target vs Actual Number of People working in the Class 2 area of the Packing Line during this Packrun
+ * @property {?number} totalManningTarget Target Number of People working on the Packing Line during this Packrun
+ * @property {?number} averageTotalManning Average Number of People working on the Packing Line during this Packrun
+ * @property {?number} totalManningPercentage Percentage of Target vs Actual Number of People working on the Packing Line during this Packrun
+ * @property {?number} costPerManningUnitHour Average Cost ($) per Person per Hour working on the Packing Line for this Packrun
+ * @property {number} totalHoursWorked Total Hours Worked during this Packrun. Directly relates to Production Time
+ * @property {number} totalHoursWorkedExcludingDowntime Total Hours Worked excluding Downtime during this Packrun. Directly relates to Production Time less Downtime
+ * @property {number} totalHoursPaid Total Hours Paid during this Packrun. Directly relates to Production Time and the Paid portion of Scheduled Break Time combined
+ * @property {?number} class1TotalManningCost Total Cost ($) of Manning the Packing Line (excluding Class 2) during this Packrun
+ * @property {?number} class2TotalManningCost Total Cost ($) of Manning the Class 2 area of the Packing Line during this Packrun
+ * @property {?number} class1DowntimeManningCost Cost ($) of Manning the Packing Line (excluding Class 2) in all Downtime Events during this Packrun
+ * @property {?number} class2DowntimeManningCost Total Cost ($) of Manning the Class 2 area of the Packing Line in all Downtime Events during this Packrun
+ * @property {?number} class1CostPerTrayTarget Target Cost (cents) per Class 1 Tray Equivalent Produced during this Packrun
+ * @property {?number} class1CostPerTrayActual Actual Cost (cents) per Class 1 Tray Equivalent Produced during this Packrun
+ * @property {?number} class2CostPerTrayActual Actual Cost (cents) per Class 2 Tray Equivalent Produced during this Packrun
+ * @property {number} class1TraysPerHour Average Class 1 Tray Equivalents Produced per Hour during this Packrun
+ * @property {number} class1TraysPerHourExcludingDowntime Average Class 1 Tray Equivalents Produced per Hour excluding Downtime during this Packrun
+ * @property {number} class1TraysPerHourExcludingDowntimeTarget Target Class 1 Tray Equivalents to Produce per Hour excluding Downtime during this Packrun
+ * @property {?number} class1TraysPerManHour Average Class 1 Tray Equivalents Produced per Person per Hour during this Packrun
+ * @property {?number} class1TraysPerManHourExcludingDowntime Average Class 1 Tray Equivalents Produced per Person per Hour excluding Downtime during this Packrun
+ * @property {number} class2TraysPerHour Average Class 2 Tray Equivalents Produced per Hour during this Packrun
+ * @property {number} class2TraysPerHourExcludingDowntime Average Class 2 Tray Equivalents Produced per Hour excluding Downtime during this Packrun
+ * @property {?number} class2TraysPerManHour Average Class 2 Tray Equivalents Produced per Person per Hour during this Packrun
+ * @property {?number} class2TraysPerManHourExcludingDowntime Average Class 2 Tray Equivalents Produced per Person per Hour excluding Downtime during this Packrun
+ * @property {?number} class1LayeredPercentageTarget Target Percentage of Layered Trays that should be Produced for this Packrun
+ * @property {?number} class1LayeredPercentage Actual Percentage of Layered Trays that were Produced during this Packrun
+ * @property {?number} class1BulkPercentage Actual Percentage of Bulk Packs that were Produced during this Packrun
+ * @memberof Controllers.Packhouse
+ */
+
+/**
+ * A **ShiftData** Type
+ * 
+ * @typedef {Object} ProductionDataExportController.ShiftData
+ * @property {number} siteId ID of the Site where this Shift took place
+ * @property {string} siteName Name of the Site where this Shift took place
+ * @property {string} packingLineId ID of the Packing Line where this Shift took place
+ * @property {string} packingLineName Name of the Packing Line where this Shift took place
+ * @property {string} shiftId ID of the Shift
+ * @property {string} shiftType Type of the Shift
+ * @property {number} isoWeek ISO Week when this Shift occurred
+ * @property {Date} startTimestamp Timestamp when this Shift was Started
+ * @property {?Date} finishTimestamp Timestamp when this Shift was Finished
+ * @property {?string} lineManagerName Name of the Line Manager who ran this Shift
+ * @property {?string} qualityManagerName Name of the Quality Manager who ran this Shift
+ * @property {string[]} varietyIds An Array of Variety IDs that were Packed during this Shift
+ * @property {string[]} varietyCodes An Array of Variety Codes that were Packed during this Shift
+ * @property {string[]} growingMethodIds An Array of Growing Method IDs that were Packed during this Shift
+ * @property {string[]} growingMethodCodes An Array of Growing Method Codes that were Packed during this Shift
+ * @property {number} binsTippedTarget Target Number of Bins to Tip during this Shift
+ * @property {number} totalBinsTipped Total Number of Bins Tipped during this Shift
+ * @property {number} binsTippedPerHour Number of Bins Tipped per Hour during this Shift
+ * @property {number} binsTippedPerHourExcludingDowntime Number of Bins Tipped per Hour excluding Downtime during this Shift
+ * @property {number} totalProductionTime Total Production Time in Seconds for this Shift
+ * @property {number} totalScheduledBreakTime Total Scheduled Break Time in Seconds for this Shift
+ * @property {number} totalDowntime Total Downtime in Seconds for this Shift
+ * @property {number} downtimeEventsCount Number of Downtime Events that occurred during this Shift
+ * @property {number} downtimeEventsAverageDuration Average Duration in Seconds of a Downtime Event during this Shift
+ * @property {?number} class1ManningTarget Target Number of People working on the Packing Line (excluding Class 2) during this Shift
+ * @property {?number} averageClass1Manning Average Number of People working on the Packing Line (excluding Class 2) during this Shift
+ * @property {?number} class1ManningPercentage Percentage of Target vs Actual Number of People working on the Packing Line (excluding Class 2) during this Shift
+ * @property {?number} class2ManningTarget Target Number of People working in the Class 2 area of the Packing Line during this Shift
+ * @property {?number} averageClass2Manning Average Number of People working in the Class 2 area of the Packing Line during this Shift
+ * @property {?number} class2ManningPercentage Percentage of Target vs Actual Number of People working in the Class 2 area of the Packing Line during this Shift
+ * @property {?number} totalManningTarget Target Number of People working on the Packing Line during this Shift
+ * @property {?number} averageTotalManning Average Number of People working on the Packing Line during this Shift
+ * @property {?number} totalManningPercentage Percentage of Target vs Actual Number of People working on the Packing Line during this Shift
+ * @property {?number} costPerManningUnitHour Average Cost ($) per Person per Hour working on the Packing Line for this Shift
+ * @property {number} totalHoursWorked Total Hours Worked during this Shift. Directly relates to Production Time
+ * @property {number} totalHoursWorkedExcludingDowntime Total Hours Worked excluding Downtime during this Shift. Directly relates to Production Time less Downtime
+ * @property {number} totalHoursPaid Total Hours Paid during this Shift. Directly relates to Production Time and the Paid portion of Scheduled Break Time combined
+ * @property {?number} class1TotalManningCost Total Cost ($) of Manning the Packing Line (excluding Class 2) during this Shift
+ * @property {?number} class2TotalManningCost Total Cost ($) of Manning the Class 2 area of the Packing Line during this Shift
+ * @property {?number} class1DowntimeManningCost Cost ($) of Manning the Packing Line (excluding Class 2) in all Downtime Events during this Shift
+ * @property {?number} class2DowntimeManningCost Total Cost ($) of Manning the Class 2 area of the Packing Line in all Downtime Events during this Shift
+ * @property {?number} class1CostPerTrayTarget Target Cost (cents) per Class 1 Tray Equivalent Produced during this Shift
+ * @property {?number} class1CostPerTrayActual Actual Cost (cents) per Class 1 Tray Equivalent Produced during this Shift
+ * @property {?number} class2CostPerTrayActual Actual Cost (cents) per Class 2 Tray Equivalent Produced during this Shift
+ * @property {number} totalClass1Trays Total Class 1 Tray Equivalents Produced during this Shift
+ * @property {number} totalClass2Trays Total Class 2 Tray Equivalents Produced during this Shift
+ * @property {number} class1TraysPerHour Average Class 1 Tray Equivalents Produced per Hour during this Shift
+ * @property {number} class1TraysPerHourExcludingDowntime Average Class 1 Tray Equivalents Produced per Hour excluding Downtime during this Shift
+ * @property {number} class1TraysPerHourExcludingDowntimeTarget Target Class 1 Tray Equivalents to Produce per Hour excluding Downtime during this Shift
+ * @property {?number} class1TraysPerManHour Average Class 1 Tray Equivalents Produced per Person per Hour during this Shift
+ * @property {?number} class1TraysPerManHourExcludingDowntime Average Class 1 Tray Equivalents Produced per Person per Hour excluding Downtime during this Shift
+ * @property {number} class2TraysPerHour Average Class 2 Tray Equivalents Produced per Hour during this Shift
+ * @property {number} class2TraysPerHourExcludingDowntime Average Class 2 Tray Equivalents Produced per Hour excluding Downtime during this Shift
+ * @property {?number} class2TraysPerManHour Average Class 2 Tray Equivalents Produced per Person per Hour during this Shift
+ * @property {?number} class2TraysPerManHourExcludingDowntime Average Class 2 Tray Equivalents Produced per Person per Hour excluding Downtime during this Shift
+ * @property {?number} class1LayeredPercentageTarget Target Percentage of Layered Trays that should be Produced for this Shift
+ * @property {?number} class1LayeredPercentage Actual Percentage of Layered Trays that were Produced during this Shift
+ * @property {?number} class1BulkPercentage Actual Percentage of Bulk Packs that were Produced during this Shift
+ * @property {?number} averageClass1Percentage Average Class 1 Packout Percentage during this Shift
+ * @property {?number} qualityR600IdealSamplesTarget Target Percentage of R600 Samples that should be in the Ideal Range for this Shift
+ * @property {?number} qualityR600IdealSamplesActual Actual Percentage of R600 Samples that were in the Ideal Range during this Shift
+ * @property {?number} satisfactionRating An Optional Satisfaction Rating between 1 and 10 from the Line Manager of this Shift
+ * @property {?number} keyCelebration An Optional Key Celebration the Line Manager observed during this Shift
+ * @property {?number} keyChallenge An Optional Key Challenge the Line Manager observed during this Shift
+ * @memberof Controllers.Packhouse
+ */
+
+/**
+ * A **ShiftHourlyData** Type
+ * 
+ * @typedef {Object} ProductionDataExportController.ShiftHourlyData
+ * @property {number} siteId ID of the Site where this Hour took place
+ * @property {string} siteName Name of the Site where this Hour took place
+ * @property {string} packingLineId ID of the Packing Line where this Hour took place
+ * @property {string} packingLineName Name of the Packing Line where this Hour took place
+ * @property {string} shiftId ID of the Shift associated with this Hourly Entry
+ * @property {string} shiftType Type of the Shift associated with this Hourly Entry
+ * @property {number} isoWeek ISO Week when this Hour Started
+ * @property {Date} startTimestamp Timestamp when this Hour Started
+ * @property {?Date} endTimestamp Timestamp when this Hour Ended
+ * @property {?string} lineManagerName Name of the Line Manager who ran this Hour
+ * @property {?string} qualityManagerName Name of the Quality Manager who ran this Hour
+ * @property {string[]} varietyIds An Array of Variety IDs that were Packed during this Hour
+ * @property {string[]} varietyCodes An Array of Variety Codes that were Packed during this Hour
+ * @property {string[]} growingMethodIds An Array of Growing Method IDs that were Packed during this Hour
+ * @property {string[]} growingMethodCodes An Array of Growing Method Codes that were Packed during this Hour
+ * @property {number} totalBinsTipped Total Number of Bins Tipped during this Hour
+ * @property {number} totalProductionTime Total Production Time in Seconds for this Hour
+ * @property {number} totalScheduledBreakTime Total Scheduled Break Time in Seconds for this Hour
+ * @property {number} totalDowntime Total Downtime in Seconds for this Hour
+ * @property {number} downtimeEventsCount Number of Downtime Events that occurred during this Hour
+ * @property {number} downtimeEventsAverageDuration Average Duration in Seconds of a Downtime Event during this Hour
+ * @property {?number} class1ManningTarget Target Number of People working on the Packing Line (excluding Class 2) during this Hour
+ * @property {?number} class1Manning Actual Number of People working on the Packing Line (excluding Class 2) during this Hour
+ * @property {?number} class1ManningPercentage Percentage of Target vs Actual Number of People working on the Packing Line (excluding Class 2) during this Hour
+ * @property {?number} class2ManningTarget Target Number of People working in the Class 2 area of the Packing Line during this Hour
+ * @property {?number} class2Manning Actual Number of People working in the Class 2 area of the Packing Line during this Hour
+ * @property {?number} class2ManningPercentage Percentage of Target vs Actual Number of People working in the Class 2 area of the Packing Line during this Hour
+ * @property {?number} totalManningTarget Target Number of People working on the Packing Line during this Hour
+ * @property {?number} totalManning Actual Number of People working on the Packing Line during this Hour
+ * @property {?number} totalManningPercentage Percentage of Target vs Actual Number of People working on the Packing Line during this Hour
+ * @property {?number} costPerManningUnitHour Average Cost ($) per Person per Hour working on the Packing Line for this Hour
+ * @property {number} totalMinutesWorked Total Hours Worked during this Hour. Directly relates to Production Time
+ * @property {number} totalMinutesWorkedExcludingDowntime Total Hours Worked excluding Downtime during this Hour. Directly relates to Production Time less Downtime
+ * @property {number} totalMinutesPaid Total Hours Paid during this Hour. Directly relates to Production Time and the Paid portion of Scheduled Break Time combined
+ * @property {?number} class1TotalManningCost Total Cost ($) of Manning the Packing Line (excluding Class 2) during this Hour
+ * @property {?number} class2TotalManningCost Total Cost ($) of Manning the Class 2 area of the Packing Line during this Hour
+ * @property {?number} class1DowntimeManningCost Cost ($) of Manning the Packing Line (excluding Class 2) in all Downtime Events during this Hour
+ * @property {?number} class2DowntimeManningCost Total Cost ($) of Manning the Class 2 area of the Packing Line in all Downtime Events during this Hour
+ * @property {?number} class1CostPerTrayTarget Target Cost (cents) per Class 1 Tray Equivalent Produced during this Hour
+ * @property {?number} class1CostPerTrayActual Actual Cost (cents) per Class 1 Tray Equivalent Produced during this Hour
+ * @property {?number} class2CostPerTrayActual Actual Cost (cents) per Class 2 Tray Equivalent Produced during this Hour
+ * @property {number} totalClass1Trays Total Class 1 Tray Equivalents Produced during this Hour
+ * @property {number} totalClass2Trays Total Class 2 Tray Equivalents Produced during this Hour
+ * @property {number} class1TraysPerHourExcludingDowntime Average Class 1 Tray Equivalents Produced per Hour excluding Downtime during this Hour
+ * @property {number} class1TraysPerHourExcludingDowntimeTarget Target Class 1 Tray Equivalents to Produce per Hour excluding Downtime during this Hour
+ * @property {?number} class1TraysPerManHourExcludingDowntime Average Class 1 Tray Equivalents Produced per Person per Hour excluding Downtime during this Hour
+ * @property {number} class2TraysPerHourExcludingDowntime Average Class 2 Tray Equivalents Produced per Hour excluding Downtime during this Hour
+ * @property {?number} class2TraysPerManHourExcludingDowntime Average Class 2 Tray Equivalents Produced per Person per Hour excluding Downtime during this Hour
+ * @property {?number} class1LayeredPercentageTarget Target Percentage of Layered Trays that should be Produced for this Hour
+ * @property {?number} class1LayeredPercentage Actual Percentage of Layered Trays that were Produced during this Hour
+ * @property {?number} class1BulkPercentage Actual Percentage of Bulk Packs that were Produced during this Hour
+ * @property {?number} averageClass1Percentage Average Class 1 Packout Percentage during this Hour
+ * @property {?number} qualityR600IdealSamplesTarget Target Percentage of R600 Samples that should be in the Ideal Range for this Hour
+ * @property {?number} qualityR600IdealSamplesActual Actual Percentage of R600 Samples that were in the Ideal Range during this Hour
+ * @memberof Controllers.Packhouse
+ */
+
+/**
+ * A **DowntimeData** Type
+ * 
+ * @typedef {Object} ProductionDataExportController.DowntimeData
+ * @property {number} siteId ID of the Site where this Downtime Event occurred
+ * @property {string} siteName Name of the Site where this Downtime Event occurred
+ * @property {string} packingLineId ID of the Packing Line where this Downtime Event occurred
+ * @property {string} packingLineName Name of the Packing Line where this Downtime Event occurred
+ * @property {string} shiftId ID of the Shift associated with this Downtime Event
+ * @property {string} shiftType Type of the Shift associated with this Downtime Event
+ * @property {number} isoWeek ISO Week when this Downtime Event occurred
+ * @property {Date} startTimestamp Timestamp when this Downtime Event Started
+ * @property {?Date} endTimestamp Timestamp when this Downtime Event Ended
+ * @property {?string} reasonCategory Reason Category for this Downtime Event
+ * @property {?string} reasonTag Reason Tag for this Downtime Event
+ * @property {?string} remedyAction An Optional Summary of the Action taken to Remedy this Downtime Event
+ * @memberof Controllers.Packhouse
+ */
+
+/**
+ * A **PackagingConsumptionData** Type
+ * 
+ * @typedef {Object} ProductionDataExportController.PackagingConsumptionData
+ * @property {number} siteId ID of the Site where this Packaging Consumption occurred
+ * @property {string} siteName Name of the Site where this Packaging Consumption occurred
+ * @property {string} packingLineId ID of the Packing Line where this Packaging Consumption occurred
+ * @property {string} packingLineName Name of the Packing Line where this Packaging Consumption occurred
+ * @property {string} packrunId ID of the Packrun associated with this Packaging Consumption
+ * @property {string} packrunName Name of the Packrun associated with this Packaging Consumption
+ * @property {string} varietyId ID of the Variety associated with this Packaging Consumption
+ * @property {string} varietyCode Code of the Variety associated with this Packaging Consumption
+ * @property {number} isoWeek ISO Week when this Packaging Consumption occurred
+ * @property {Date} startTimestamp Timestamp when this Packaging Consumption Started
+ * @property {?Date} endTimestamp Timestamp when this Packaging Consumption Ended
+ * @property {string} packType Pack Type of the Packaging Consumed
+ * @property {number} quantity Quantity of Packaging Consumed
+ * @memberof Controllers.Packhouse
+ */
+
+/**
+ * A **ProductionData** Type
+ * 
+ * @typedef {Object} ProductionDataExportController.ProductionData
+ * @property {Array<ProductionDataExportController.PackrunData>} packruns An Array of Packrun Data
+ * @property {Array<ProductionDataExportController.ShiftData>} shifts An Array of Shift Data
+ * @property {Array<ProductionDataExportController.ShiftHourlyData>} shiftHourlyEntries An Array of Shift Hourly Entry Data
+ * @property {Array<ProductionDataExportController.DowntimeData>} downtimeEvents An Array of Downtime Event Data
+ * @property {Array<ProductionDataExportController.PackagingConsumptionData>} packagingConsumption An Array of Packaging Consumption Data
+ * @memberof Controllers.Packhouse
+ */
+
+exports.default = _default;