@ricado/api-client 2.6.0 → 2.7.0

package/lib/Models/Packhouse/Site/ReemoonSizerModel.js

@@ -0,0 +1,1272 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _BaseModel2 = _interopRequireDefault(require("../../../Models/BaseModel"));
+
+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; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+/**
+ * Model Class for a Reemoon Sizer
+ * 
+ * @class
+ * @hideconstructor
+ * @extends BaseModel
+ */
+var ReemoonSizerModel = /*#__PURE__*/function (_BaseModel) {
+  _inherits(ReemoonSizerModel, _BaseModel);
+
+  var _super = _createSuper(ReemoonSizerModel);
+
+  /**
+   * ReemoonSizerModel Constructor
+   * 
+   * @protected
+   * @param {number} siteId The Site ID associated with this Reemoon Sizer
+   */
+  function ReemoonSizerModel(siteId) {
+    var _this;
+
+    _classCallCheck(this, ReemoonSizerModel);
+
+    _this = _super.call(this);
+    /**
+     * The Reemoon Sizer ID
+     * 
+     * @type {string}
+     * @public
+     */
+
+    _this.id = "";
+    /**
+     * The RTU this Reemoon Sizer belongs to
+     * 
+     * @type {?number}
+     * @public
+     */
+
+    _this.rtuId = null;
+    /**
+     * The Reemoon Sizer Name
+     * 
+     * @type {string}
+     * @public
+     */
+
+    _this.name = "";
+    /**
+     * The Packing Line ID that manages this Reemoon Sizer
+     * 
+     * @type {string}
+     * @public
+     */
+
+    _this.packingLineId = "";
+    /**
+     * The Sizer Type
+     * 
+     * @type {string}
+     * @public
+     */
+
+    _this.sizerType = "";
+    /**
+     * The Auto Create Batch Delay in Seconds for this Reemoon Sizer
+     * 
+     * @type {number}
+     * @public
+     */
+
+    _this.autoCreateBatchDelay = 0;
+    /**
+     * The Points used by this Reemoon Sizer
+     * 
+     * @type {{currentBatchId: number, currentBatchName: number, currentBatchVarietyCode: number, currentBatchStartTimestamp: number, currentBatchPackrunId: number, currentBatchPackrunName: number, machineAverageFruitWeight: number, machineAverageFruitSize: number, machineCupFill: number, machineIncomingFruitPerMinute: number, machineRecycledFruitPerMinute: number, machineTraysPerHour: number, machineTonnesPerHour: number, machineRodsPerMinute: number, machineIncomingFruitPerMinuteBySize: ?number, machineRecycledFruitPerMinuteBySize: ?number, machineLanesFruitPerMinuteBySize: ?number, createNewBatchRequest: number, createBatchOnPackrunChange: number, createBatchOnTimeBatchChange: number, outletGroupSummaries: number, products: number, packTypeOutletUtilizationTargets: number, class1TraysPerHour: ?number}}
+     * @public
+     */
+
+    _this.points = function () {
+      var pointsDefaultValue = {};
+      pointsDefaultValue.currentBatchId = 0;
+      pointsDefaultValue.currentBatchName = 0;
+      pointsDefaultValue.currentBatchVarietyCode = 0;
+      pointsDefaultValue.currentBatchStartTimestamp = 0;
+      pointsDefaultValue.currentBatchPackrunId = 0;
+      pointsDefaultValue.currentBatchPackrunName = 0;
+      pointsDefaultValue.machineAverageFruitWeight = 0;
+      pointsDefaultValue.machineAverageFruitSize = 0;
+      pointsDefaultValue.machineCupFill = 0;
+      pointsDefaultValue.machineIncomingFruitPerMinute = 0;
+      pointsDefaultValue.machineRecycledFruitPerMinute = 0;
+      pointsDefaultValue.machineTraysPerHour = 0;
+      pointsDefaultValue.machineTonnesPerHour = 0;
+      pointsDefaultValue.machineRodsPerMinute = 0;
+      pointsDefaultValue.machineIncomingFruitPerMinuteBySize = null;
+      pointsDefaultValue.machineRecycledFruitPerMinuteBySize = null;
+      pointsDefaultValue.machineLanesFruitPerMinuteBySize = null;
+      pointsDefaultValue.createNewBatchRequest = 0;
+      pointsDefaultValue.createBatchOnPackrunChange = 0;
+      pointsDefaultValue.createBatchOnTimeBatchChange = 0;
+      pointsDefaultValue.outletGroupSummaries = 0;
+      pointsDefaultValue.products = 0;
+      pointsDefaultValue.packTypeOutletUtilizationTargets = 0;
+      pointsDefaultValue.class1TraysPerHour = null;
+      return pointsDefaultValue;
+    }();
+    /**
+     * The Lanes defined for this Reemoon Sizer
+     * 
+     * @type {Array<{id: string, number: number, points: {cupFill: number}}>}
+     * @public
+     */
+
+
+    _this.lanes = [];
+    /**
+     * The Outlets defined for this Reemoon Sizer
+     * 
+     * @type {Array<{id: string, number: number, type: string, points: {name: number, fruitPerMinute: number, packsPerMinute: number, utilization: number, status: number, productId: number, productName: number}}>}
+     * @public
+     */
+
+    _this.outlets = [];
+    /**
+     * The Fruit Sizes defined and handled by this Reemoon Sizer
+     * 
+     * @type {Array<{fruitSize: string, points: {incomingFruitPerMinute: number, recycledFruitPerMinute: number, allocatedFruitPerMinute: number}}>}
+     * @public
+     */
+
+    _this.fruitSizes = [];
+    /**
+     * The FreshPack Integration Configuration for this Reemoon Sizer
+     * 
+     * @type {?{points: Object, enabled: boolean, materialGroupId: number, binTypeId: number, bulkWeightClassTypes: string[]}}
+     * @public
+     */
+
+    _this.freshPackIntegration = null;
+    /**
+     * The Reemoon Integration Configuration for this Reemoon Sizer
+     * 
+     * @type {{points: {apiCommunicationStatus: number, machineId: number, machineName: number, machineLaneCount: number, machineOutletCount: number, machineOutletDetails: number}, enabled: boolean, username: string, password: string, apiBaseUrl: string}}
+     * @public
+     */
+
+    _this.reemoonIntegration = function () {
+      var reemoonIntegrationDefaultValue = {};
+
+      reemoonIntegrationDefaultValue.points = function () {
+        var pointsDefaultValue = {};
+        pointsDefaultValue.apiCommunicationStatus = 0;
+        pointsDefaultValue.machineId = 0;
+        pointsDefaultValue.machineName = 0;
+        pointsDefaultValue.machineLaneCount = 0;
+        pointsDefaultValue.machineOutletCount = 0;
+        pointsDefaultValue.machineOutletDetails = 0;
+        return pointsDefaultValue;
+      }();
+
+      reemoonIntegrationDefaultValue.enabled = false;
+      reemoonIntegrationDefaultValue.username = "";
+      reemoonIntegrationDefaultValue.password = "";
+      reemoonIntegrationDefaultValue.apiBaseUrl = "";
+      return reemoonIntegrationDefaultValue;
+    }();
+    /**
+     * An Array of Sources that deliver Fruit to this Reemoon Sizer
+     * 
+     * @type {Array<{type: string, riserId: string}|{type: string, sizerId: string, outletNumbers: number[]}>}
+     * @public
+     */
+
+
+    _this.sources = [];
+    /**
+     * An Array of Product to Class Type Maps for this Reemoon Sizer
+     * 
+     * @type {Array<{productName: string, classType: string, matchType: string}>}
+     * @public
+     */
+
+    _this.productClassTypes = [];
+    /**
+     * Whether the Reemoon Sizer has been deleted
+     * 
+     * @type {boolean}
+     * @public
+     */
+
+    _this.deleted = false;
+    /**
+     * When the Reemoon Sizer was last updated
+     * 
+     * @type {Date}
+     * @public
+     */
+
+    _this.updateTimestamp = new Date();
+    /**
+     * The Site ID associated with this Reemoon Sizer
+     * 
+     * @type {number}
+     * @public
+     */
+
+    _this.siteId = siteId;
+    return _this;
+  }
+  /**
+   * Create a new **ReemoonSizerModel** from a JSON Object or JSON String
+   * 
+   * @static
+   * @public
+   * @param {Object<string, any>|string} json A JSON Object or JSON String
+   * @param {number} siteId The Site ID associated with this Reemoon Sizer
+   * @return {ReemoonSizerModel}
+   */
+
+
+  _createClass(ReemoonSizerModel, null, [{
+    key: "fromJSON",
+    value: function fromJSON(json, siteId) {
+      var model = new ReemoonSizerModel(siteId);
+      /**
+       * The JSON Object
+       * 
+       * @type {Object<string, any>}
+       */
+
+      var jsonObject = {};
+
+      if (typeof json === 'string') {
+        jsonObject = JSON.parse(json);
+      } else if (_typeof(json) === 'object') {
+        jsonObject = json;
+      }
+
+      if ('id' in jsonObject) {
+        model.id = function () {
+          if (typeof jsonObject['id'] !== 'string') {
+            return String(jsonObject['id']);
+          }
+
+          return jsonObject['id'];
+        }();
+      }
+
+      if ('rtuId' in jsonObject) {
+        model.rtuId = function () {
+          if (jsonObject['rtuId'] === null) {
+            return null;
+          }
+
+          if (typeof jsonObject['rtuId'] !== 'number') {
+            return Number.isInteger(Number(jsonObject['rtuId'])) ? Number(jsonObject['rtuId']) : Math.floor(Number(jsonObject['rtuId']));
+          }
+
+          return Number.isInteger(jsonObject['rtuId']) ? jsonObject['rtuId'] : Math.floor(jsonObject['rtuId']);
+        }();
+      }
+
+      if ('name' in jsonObject) {
+        model.name = function () {
+          if (typeof jsonObject['name'] !== 'string') {
+            return String(jsonObject['name']);
+          }
+
+          return jsonObject['name'];
+        }();
+      }
+
+      if ('packingLineId' in jsonObject) {
+        model.packingLineId = function () {
+          if (typeof jsonObject['packingLineId'] !== 'string') {
+            return String(jsonObject['packingLineId']);
+          }
+
+          return jsonObject['packingLineId'];
+        }();
+      }
+
+      if ('sizerType' in jsonObject) {
+        model.sizerType = function () {
+          if (typeof jsonObject['sizerType'] !== 'string') {
+            return String(jsonObject['sizerType']);
+          }
+
+          return jsonObject['sizerType'];
+        }();
+      }
+
+      if ('autoCreateBatchDelay' in jsonObject) {
+        model.autoCreateBatchDelay = function () {
+          if (typeof jsonObject['autoCreateBatchDelay'] !== 'number') {
+            return Number.isInteger(Number(jsonObject['autoCreateBatchDelay'])) ? Number(jsonObject['autoCreateBatchDelay']) : Math.floor(Number(jsonObject['autoCreateBatchDelay']));
+          }
+
+          return Number.isInteger(jsonObject['autoCreateBatchDelay']) ? jsonObject['autoCreateBatchDelay'] : Math.floor(jsonObject['autoCreateBatchDelay']);
+        }();
+      }
+
+      if ('points' in jsonObject) {
+        model.points = function () {
+          var pointsObject = {};
+
+          if (_typeof(jsonObject['points']) === 'object' && 'currentBatchId' in jsonObject['points']) {
+            pointsObject.currentBatchId = function () {
+              if (typeof jsonObject['points'].currentBatchId !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].currentBatchId)) ? Number(jsonObject['points'].currentBatchId) : Math.floor(Number(jsonObject['points'].currentBatchId));
+              }
+
+              return Number.isInteger(jsonObject['points'].currentBatchId) ? jsonObject['points'].currentBatchId : Math.floor(jsonObject['points'].currentBatchId);
+            }();
+          } else {
+            pointsObject.currentBatchId = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'currentBatchName' in jsonObject['points']) {
+            pointsObject.currentBatchName = function () {
+              if (typeof jsonObject['points'].currentBatchName !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].currentBatchName)) ? Number(jsonObject['points'].currentBatchName) : Math.floor(Number(jsonObject['points'].currentBatchName));
+              }
+
+              return Number.isInteger(jsonObject['points'].currentBatchName) ? jsonObject['points'].currentBatchName : Math.floor(jsonObject['points'].currentBatchName);
+            }();
+          } else {
+            pointsObject.currentBatchName = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'currentBatchVarietyCode' in jsonObject['points']) {
+            pointsObject.currentBatchVarietyCode = function () {
+              if (typeof jsonObject['points'].currentBatchVarietyCode !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].currentBatchVarietyCode)) ? Number(jsonObject['points'].currentBatchVarietyCode) : Math.floor(Number(jsonObject['points'].currentBatchVarietyCode));
+              }
+
+              return Number.isInteger(jsonObject['points'].currentBatchVarietyCode) ? jsonObject['points'].currentBatchVarietyCode : Math.floor(jsonObject['points'].currentBatchVarietyCode);
+            }();
+          } else {
+            pointsObject.currentBatchVarietyCode = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'currentBatchStartTimestamp' in jsonObject['points']) {
+            pointsObject.currentBatchStartTimestamp = function () {
+              if (typeof jsonObject['points'].currentBatchStartTimestamp !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].currentBatchStartTimestamp)) ? Number(jsonObject['points'].currentBatchStartTimestamp) : Math.floor(Number(jsonObject['points'].currentBatchStartTimestamp));
+              }
+
+              return Number.isInteger(jsonObject['points'].currentBatchStartTimestamp) ? jsonObject['points'].currentBatchStartTimestamp : Math.floor(jsonObject['points'].currentBatchStartTimestamp);
+            }();
+          } else {
+            pointsObject.currentBatchStartTimestamp = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'currentBatchPackrunId' in jsonObject['points']) {
+            pointsObject.currentBatchPackrunId = function () {
+              if (typeof jsonObject['points'].currentBatchPackrunId !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].currentBatchPackrunId)) ? Number(jsonObject['points'].currentBatchPackrunId) : Math.floor(Number(jsonObject['points'].currentBatchPackrunId));
+              }
+
+              return Number.isInteger(jsonObject['points'].currentBatchPackrunId) ? jsonObject['points'].currentBatchPackrunId : Math.floor(jsonObject['points'].currentBatchPackrunId);
+            }();
+          } else {
+            pointsObject.currentBatchPackrunId = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'currentBatchPackrunName' in jsonObject['points']) {
+            pointsObject.currentBatchPackrunName = function () {
+              if (typeof jsonObject['points'].currentBatchPackrunName !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].currentBatchPackrunName)) ? Number(jsonObject['points'].currentBatchPackrunName) : Math.floor(Number(jsonObject['points'].currentBatchPackrunName));
+              }
+
+              return Number.isInteger(jsonObject['points'].currentBatchPackrunName) ? jsonObject['points'].currentBatchPackrunName : Math.floor(jsonObject['points'].currentBatchPackrunName);
+            }();
+          } else {
+            pointsObject.currentBatchPackrunName = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'machineAverageFruitWeight' in jsonObject['points']) {
+            pointsObject.machineAverageFruitWeight = function () {
+              if (typeof jsonObject['points'].machineAverageFruitWeight !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].machineAverageFruitWeight)) ? Number(jsonObject['points'].machineAverageFruitWeight) : Math.floor(Number(jsonObject['points'].machineAverageFruitWeight));
+              }
+
+              return Number.isInteger(jsonObject['points'].machineAverageFruitWeight) ? jsonObject['points'].machineAverageFruitWeight : Math.floor(jsonObject['points'].machineAverageFruitWeight);
+            }();
+          } else {
+            pointsObject.machineAverageFruitWeight = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'machineAverageFruitSize' in jsonObject['points']) {
+            pointsObject.machineAverageFruitSize = function () {
+              if (typeof jsonObject['points'].machineAverageFruitSize !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].machineAverageFruitSize)) ? Number(jsonObject['points'].machineAverageFruitSize) : Math.floor(Number(jsonObject['points'].machineAverageFruitSize));
+              }
+
+              return Number.isInteger(jsonObject['points'].machineAverageFruitSize) ? jsonObject['points'].machineAverageFruitSize : Math.floor(jsonObject['points'].machineAverageFruitSize);
+            }();
+          } else {
+            pointsObject.machineAverageFruitSize = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'machineCupFill' in jsonObject['points']) {
+            pointsObject.machineCupFill = function () {
+              if (typeof jsonObject['points'].machineCupFill !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].machineCupFill)) ? Number(jsonObject['points'].machineCupFill) : Math.floor(Number(jsonObject['points'].machineCupFill));
+              }
+
+              return Number.isInteger(jsonObject['points'].machineCupFill) ? jsonObject['points'].machineCupFill : Math.floor(jsonObject['points'].machineCupFill);
+            }();
+          } else {
+            pointsObject.machineCupFill = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'machineIncomingFruitPerMinute' in jsonObject['points']) {
+            pointsObject.machineIncomingFruitPerMinute = function () {
+              if (typeof jsonObject['points'].machineIncomingFruitPerMinute !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].machineIncomingFruitPerMinute)) ? Number(jsonObject['points'].machineIncomingFruitPerMinute) : Math.floor(Number(jsonObject['points'].machineIncomingFruitPerMinute));
+              }
+
+              return Number.isInteger(jsonObject['points'].machineIncomingFruitPerMinute) ? jsonObject['points'].machineIncomingFruitPerMinute : Math.floor(jsonObject['points'].machineIncomingFruitPerMinute);
+            }();
+          } else {
+            pointsObject.machineIncomingFruitPerMinute = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'machineRecycledFruitPerMinute' in jsonObject['points']) {
+            pointsObject.machineRecycledFruitPerMinute = function () {
+              if (typeof jsonObject['points'].machineRecycledFruitPerMinute !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].machineRecycledFruitPerMinute)) ? Number(jsonObject['points'].machineRecycledFruitPerMinute) : Math.floor(Number(jsonObject['points'].machineRecycledFruitPerMinute));
+              }
+
+              return Number.isInteger(jsonObject['points'].machineRecycledFruitPerMinute) ? jsonObject['points'].machineRecycledFruitPerMinute : Math.floor(jsonObject['points'].machineRecycledFruitPerMinute);
+            }();
+          } else {
+            pointsObject.machineRecycledFruitPerMinute = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'machineTraysPerHour' in jsonObject['points']) {
+            pointsObject.machineTraysPerHour = function () {
+              if (typeof jsonObject['points'].machineTraysPerHour !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].machineTraysPerHour)) ? Number(jsonObject['points'].machineTraysPerHour) : Math.floor(Number(jsonObject['points'].machineTraysPerHour));
+              }
+
+              return Number.isInteger(jsonObject['points'].machineTraysPerHour) ? jsonObject['points'].machineTraysPerHour : Math.floor(jsonObject['points'].machineTraysPerHour);
+            }();
+          } else {
+            pointsObject.machineTraysPerHour = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'machineTonnesPerHour' in jsonObject['points']) {
+            pointsObject.machineTonnesPerHour = function () {
+              if (typeof jsonObject['points'].machineTonnesPerHour !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].machineTonnesPerHour)) ? Number(jsonObject['points'].machineTonnesPerHour) : Math.floor(Number(jsonObject['points'].machineTonnesPerHour));
+              }
+
+              return Number.isInteger(jsonObject['points'].machineTonnesPerHour) ? jsonObject['points'].machineTonnesPerHour : Math.floor(jsonObject['points'].machineTonnesPerHour);
+            }();
+          } else {
+            pointsObject.machineTonnesPerHour = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'machineRodsPerMinute' in jsonObject['points']) {
+            pointsObject.machineRodsPerMinute = function () {
+              if (typeof jsonObject['points'].machineRodsPerMinute !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].machineRodsPerMinute)) ? Number(jsonObject['points'].machineRodsPerMinute) : Math.floor(Number(jsonObject['points'].machineRodsPerMinute));
+              }
+
+              return Number.isInteger(jsonObject['points'].machineRodsPerMinute) ? jsonObject['points'].machineRodsPerMinute : Math.floor(jsonObject['points'].machineRodsPerMinute);
+            }();
+          } else {
+            pointsObject.machineRodsPerMinute = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'machineIncomingFruitPerMinuteBySize' in jsonObject['points']) {
+            pointsObject.machineIncomingFruitPerMinuteBySize = function () {
+              if (jsonObject['points'].machineIncomingFruitPerMinuteBySize === null) {
+                return null;
+              }
+
+              if (typeof jsonObject['points'].machineIncomingFruitPerMinuteBySize !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].machineIncomingFruitPerMinuteBySize)) ? Number(jsonObject['points'].machineIncomingFruitPerMinuteBySize) : Math.floor(Number(jsonObject['points'].machineIncomingFruitPerMinuteBySize));
+              }
+
+              return Number.isInteger(jsonObject['points'].machineIncomingFruitPerMinuteBySize) ? jsonObject['points'].machineIncomingFruitPerMinuteBySize : Math.floor(jsonObject['points'].machineIncomingFruitPerMinuteBySize);
+            }();
+          } else {
+            pointsObject.machineIncomingFruitPerMinuteBySize = null;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'machineRecycledFruitPerMinuteBySize' in jsonObject['points']) {
+            pointsObject.machineRecycledFruitPerMinuteBySize = function () {
+              if (jsonObject['points'].machineRecycledFruitPerMinuteBySize === null) {
+                return null;
+              }
+
+              if (typeof jsonObject['points'].machineRecycledFruitPerMinuteBySize !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].machineRecycledFruitPerMinuteBySize)) ? Number(jsonObject['points'].machineRecycledFruitPerMinuteBySize) : Math.floor(Number(jsonObject['points'].machineRecycledFruitPerMinuteBySize));
+              }
+
+              return Number.isInteger(jsonObject['points'].machineRecycledFruitPerMinuteBySize) ? jsonObject['points'].machineRecycledFruitPerMinuteBySize : Math.floor(jsonObject['points'].machineRecycledFruitPerMinuteBySize);
+            }();
+          } else {
+            pointsObject.machineRecycledFruitPerMinuteBySize = null;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'machineLanesFruitPerMinuteBySize' in jsonObject['points']) {
+            pointsObject.machineLanesFruitPerMinuteBySize = function () {
+              if (jsonObject['points'].machineLanesFruitPerMinuteBySize === null) {
+                return null;
+              }
+
+              if (typeof jsonObject['points'].machineLanesFruitPerMinuteBySize !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].machineLanesFruitPerMinuteBySize)) ? Number(jsonObject['points'].machineLanesFruitPerMinuteBySize) : Math.floor(Number(jsonObject['points'].machineLanesFruitPerMinuteBySize));
+              }
+
+              return Number.isInteger(jsonObject['points'].machineLanesFruitPerMinuteBySize) ? jsonObject['points'].machineLanesFruitPerMinuteBySize : Math.floor(jsonObject['points'].machineLanesFruitPerMinuteBySize);
+            }();
+          } else {
+            pointsObject.machineLanesFruitPerMinuteBySize = null;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'createNewBatchRequest' in jsonObject['points']) {
+            pointsObject.createNewBatchRequest = function () {
+              if (typeof jsonObject['points'].createNewBatchRequest !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].createNewBatchRequest)) ? Number(jsonObject['points'].createNewBatchRequest) : Math.floor(Number(jsonObject['points'].createNewBatchRequest));
+              }
+
+              return Number.isInteger(jsonObject['points'].createNewBatchRequest) ? jsonObject['points'].createNewBatchRequest : Math.floor(jsonObject['points'].createNewBatchRequest);
+            }();
+          } else {
+            pointsObject.createNewBatchRequest = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'createBatchOnPackrunChange' in jsonObject['points']) {
+            pointsObject.createBatchOnPackrunChange = function () {
+              if (typeof jsonObject['points'].createBatchOnPackrunChange !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].createBatchOnPackrunChange)) ? Number(jsonObject['points'].createBatchOnPackrunChange) : Math.floor(Number(jsonObject['points'].createBatchOnPackrunChange));
+              }
+
+              return Number.isInteger(jsonObject['points'].createBatchOnPackrunChange) ? jsonObject['points'].createBatchOnPackrunChange : Math.floor(jsonObject['points'].createBatchOnPackrunChange);
+            }();
+          } else {
+            pointsObject.createBatchOnPackrunChange = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'createBatchOnTimeBatchChange' in jsonObject['points']) {
+            pointsObject.createBatchOnTimeBatchChange = function () {
+              if (typeof jsonObject['points'].createBatchOnTimeBatchChange !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].createBatchOnTimeBatchChange)) ? Number(jsonObject['points'].createBatchOnTimeBatchChange) : Math.floor(Number(jsonObject['points'].createBatchOnTimeBatchChange));
+              }
+
+              return Number.isInteger(jsonObject['points'].createBatchOnTimeBatchChange) ? jsonObject['points'].createBatchOnTimeBatchChange : Math.floor(jsonObject['points'].createBatchOnTimeBatchChange);
+            }();
+          } else {
+            pointsObject.createBatchOnTimeBatchChange = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'outletGroupSummaries' in jsonObject['points']) {
+            pointsObject.outletGroupSummaries = function () {
+              if (typeof jsonObject['points'].outletGroupSummaries !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].outletGroupSummaries)) ? Number(jsonObject['points'].outletGroupSummaries) : Math.floor(Number(jsonObject['points'].outletGroupSummaries));
+              }
+
+              return Number.isInteger(jsonObject['points'].outletGroupSummaries) ? jsonObject['points'].outletGroupSummaries : Math.floor(jsonObject['points'].outletGroupSummaries);
+            }();
+          } else {
+            pointsObject.outletGroupSummaries = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'products' in jsonObject['points']) {
+            pointsObject.products = function () {
+              if (typeof jsonObject['points'].products !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].products)) ? Number(jsonObject['points'].products) : Math.floor(Number(jsonObject['points'].products));
+              }
+
+              return Number.isInteger(jsonObject['points'].products) ? jsonObject['points'].products : Math.floor(jsonObject['points'].products);
+            }();
+          } else {
+            pointsObject.products = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'packTypeOutletUtilizationTargets' in jsonObject['points']) {
+            pointsObject.packTypeOutletUtilizationTargets = function () {
+              if (typeof jsonObject['points'].packTypeOutletUtilizationTargets !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].packTypeOutletUtilizationTargets)) ? Number(jsonObject['points'].packTypeOutletUtilizationTargets) : Math.floor(Number(jsonObject['points'].packTypeOutletUtilizationTargets));
+              }
+
+              return Number.isInteger(jsonObject['points'].packTypeOutletUtilizationTargets) ? jsonObject['points'].packTypeOutletUtilizationTargets : Math.floor(jsonObject['points'].packTypeOutletUtilizationTargets);
+            }();
+          } else {
+            pointsObject.packTypeOutletUtilizationTargets = 0;
+          }
+
+          if (_typeof(jsonObject['points']) === 'object' && 'class1TraysPerHour' in jsonObject['points']) {
+            pointsObject.class1TraysPerHour = function () {
+              if (jsonObject['points'].class1TraysPerHour === null) {
+                return null;
+              }
+
+              if (typeof jsonObject['points'].class1TraysPerHour !== 'number') {
+                return Number.isInteger(Number(jsonObject['points'].class1TraysPerHour)) ? Number(jsonObject['points'].class1TraysPerHour) : Math.floor(Number(jsonObject['points'].class1TraysPerHour));
+              }
+
+              return Number.isInteger(jsonObject['points'].class1TraysPerHour) ? jsonObject['points'].class1TraysPerHour : Math.floor(jsonObject['points'].class1TraysPerHour);
+            }();
+          } else {
+            pointsObject.class1TraysPerHour = null;
+          }
+
+          return pointsObject;
+        }();
+      }
+
+      if ('lanes' in jsonObject) {
+        model.lanes = function () {
+          if (Array.isArray(jsonObject['lanes']) !== true) {
+            return [];
+          }
+
+          return jsonObject['lanes'].map(function (lanesItem) {
+            return function () {
+              var lanesItemObject = {};
+
+              if (_typeof(lanesItem) === 'object' && 'id' in lanesItem) {
+                lanesItemObject.id = function () {
+                  if (typeof lanesItem.id !== 'string') {
+                    return String(lanesItem.id);
+                  }
+
+                  return lanesItem.id;
+                }();
+              } else {
+                lanesItemObject.id = "";
+              }
+
+              if (_typeof(lanesItem) === 'object' && 'number' in lanesItem) {
+                lanesItemObject.number = function () {
+                  if (typeof lanesItem.number !== 'number') {
+                    return Number.isInteger(Number(lanesItem.number)) ? Number(lanesItem.number) : Math.floor(Number(lanesItem.number));
+                  }
+
+                  return Number.isInteger(lanesItem.number) ? lanesItem.number : Math.floor(lanesItem.number);
+                }();
+              } else {
+                lanesItemObject.number = 0;
+              }
+
+              if (_typeof(lanesItem) === 'object' && 'points' in lanesItem) {
+                lanesItemObject.points = function () {
+                  var pointsObject = {};
+
+                  if (_typeof(lanesItem.points) === 'object' && 'cupFill' in lanesItem.points) {
+                    pointsObject.cupFill = function () {
+                      if (typeof lanesItem.points.cupFill !== 'number') {
+                        return Number.isInteger(Number(lanesItem.points.cupFill)) ? Number(lanesItem.points.cupFill) : Math.floor(Number(lanesItem.points.cupFill));
+                      }
+
+                      return Number.isInteger(lanesItem.points.cupFill) ? lanesItem.points.cupFill : Math.floor(lanesItem.points.cupFill);
+                    }();
+                  } else {
+                    pointsObject.cupFill = 0;
+                  }
+
+                  return pointsObject;
+                }();
+              } else {
+                lanesItemObject.points = function () {
+                  var pointsDefaultValue = {};
+                  pointsDefaultValue.cupFill = 0;
+                  return pointsDefaultValue;
+                }();
+              }
+
+              return lanesItemObject;
+            }();
+          });
+        }();
+      }
+
+      if ('outlets' in jsonObject) {
+        model.outlets = function () {
+          if (Array.isArray(jsonObject['outlets']) !== true) {
+            return [];
+          }
+
+          return jsonObject['outlets'].map(function (outletsItem) {
+            return function () {
+              var outletsItemObject = {};
+
+              if (_typeof(outletsItem) === 'object' && 'id' in outletsItem) {
+                outletsItemObject.id = function () {
+                  if (typeof outletsItem.id !== 'string') {
+                    return String(outletsItem.id);
+                  }
+
+                  return outletsItem.id;
+                }();
+              } else {
+                outletsItemObject.id = "";
+              }
+
+              if (_typeof(outletsItem) === 'object' && 'number' in outletsItem) {
+                outletsItemObject.number = function () {
+                  if (typeof outletsItem.number !== 'number') {
+                    return Number.isInteger(Number(outletsItem.number)) ? Number(outletsItem.number) : Math.floor(Number(outletsItem.number));
+                  }
+
+                  return Number.isInteger(outletsItem.number) ? outletsItem.number : Math.floor(outletsItem.number);
+                }();
+              } else {
+                outletsItemObject.number = 0;
+              }
+
+              if (_typeof(outletsItem) === 'object' && 'type' in outletsItem) {
+                outletsItemObject.type = function () {
+                  if (typeof outletsItem.type !== 'string') {
+                    return String(outletsItem.type);
+                  }
+
+                  return outletsItem.type;
+                }();
+              } else {
+                outletsItemObject.type = "";
+              }
+
+              if (_typeof(outletsItem) === 'object' && 'points' in outletsItem) {
+                outletsItemObject.points = function () {
+                  var pointsObject = {};
+
+                  if (_typeof(outletsItem.points) === 'object' && 'name' in outletsItem.points) {
+                    pointsObject.name = function () {
+                      if (typeof outletsItem.points.name !== 'number') {
+                        return Number.isInteger(Number(outletsItem.points.name)) ? Number(outletsItem.points.name) : Math.floor(Number(outletsItem.points.name));
+                      }
+
+                      return Number.isInteger(outletsItem.points.name) ? outletsItem.points.name : Math.floor(outletsItem.points.name);
+                    }();
+                  } else {
+                    pointsObject.name = 0;
+                  }
+
+                  if (_typeof(outletsItem.points) === 'object' && 'fruitPerMinute' in outletsItem.points) {
+                    pointsObject.fruitPerMinute = function () {
+                      if (typeof outletsItem.points.fruitPerMinute !== 'number') {
+                        return Number.isInteger(Number(outletsItem.points.fruitPerMinute)) ? Number(outletsItem.points.fruitPerMinute) : Math.floor(Number(outletsItem.points.fruitPerMinute));
+                      }
+
+                      return Number.isInteger(outletsItem.points.fruitPerMinute) ? outletsItem.points.fruitPerMinute : Math.floor(outletsItem.points.fruitPerMinute);
+                    }();
+                  } else {
+                    pointsObject.fruitPerMinute = 0;
+                  }
+
+                  if (_typeof(outletsItem.points) === 'object' && 'packsPerMinute' in outletsItem.points) {
+                    pointsObject.packsPerMinute = function () {
+                      if (typeof outletsItem.points.packsPerMinute !== 'number') {
+                        return Number.isInteger(Number(outletsItem.points.packsPerMinute)) ? Number(outletsItem.points.packsPerMinute) : Math.floor(Number(outletsItem.points.packsPerMinute));
+                      }
+
+                      return Number.isInteger(outletsItem.points.packsPerMinute) ? outletsItem.points.packsPerMinute : Math.floor(outletsItem.points.packsPerMinute);
+                    }();
+                  } else {
+                    pointsObject.packsPerMinute = 0;
+                  }
+
+                  if (_typeof(outletsItem.points) === 'object' && 'utilization' in outletsItem.points) {
+                    pointsObject.utilization = function () {
+                      if (typeof outletsItem.points.utilization !== 'number') {
+                        return Number.isInteger(Number(outletsItem.points.utilization)) ? Number(outletsItem.points.utilization) : Math.floor(Number(outletsItem.points.utilization));
+                      }
+
+                      return Number.isInteger(outletsItem.points.utilization) ? outletsItem.points.utilization : Math.floor(outletsItem.points.utilization);
+                    }();
+                  } else {
+                    pointsObject.utilization = 0;
+                  }
+
+                  if (_typeof(outletsItem.points) === 'object' && 'status' in outletsItem.points) {
+                    pointsObject.status = function () {
+                      if (typeof outletsItem.points.status !== 'number') {
+                        return Number.isInteger(Number(outletsItem.points.status)) ? Number(outletsItem.points.status) : Math.floor(Number(outletsItem.points.status));
+                      }
+
+                      return Number.isInteger(outletsItem.points.status) ? outletsItem.points.status : Math.floor(outletsItem.points.status);
+                    }();
+                  } else {
+                    pointsObject.status = 0;
+                  }
+
+                  if (_typeof(outletsItem.points) === 'object' && 'productId' in outletsItem.points) {
+                    pointsObject.productId = function () {
+                      if (typeof outletsItem.points.productId !== 'number') {
+                        return Number.isInteger(Number(outletsItem.points.productId)) ? Number(outletsItem.points.productId) : Math.floor(Number(outletsItem.points.productId));
+                      }
+
+                      return Number.isInteger(outletsItem.points.productId) ? outletsItem.points.productId : Math.floor(outletsItem.points.productId);
+                    }();
+                  } else {
+                    pointsObject.productId = 0;
+                  }
+
+                  if (_typeof(outletsItem.points) === 'object' && 'productName' in outletsItem.points) {
+                    pointsObject.productName = function () {
+                      if (typeof outletsItem.points.productName !== 'number') {
+                        return Number.isInteger(Number(outletsItem.points.productName)) ? Number(outletsItem.points.productName) : Math.floor(Number(outletsItem.points.productName));
+                      }
+
+                      return Number.isInteger(outletsItem.points.productName) ? outletsItem.points.productName : Math.floor(outletsItem.points.productName);
+                    }();
+                  } else {
+                    pointsObject.productName = 0;
+                  }
+
+                  return pointsObject;
+                }();
+              } else {
+                outletsItemObject.points = function () {
+                  var pointsDefaultValue = {};
+                  pointsDefaultValue.name = 0;
+                  pointsDefaultValue.fruitPerMinute = 0;
+                  pointsDefaultValue.packsPerMinute = 0;
+                  pointsDefaultValue.utilization = 0;
+                  pointsDefaultValue.status = 0;
+                  pointsDefaultValue.productId = 0;
+                  pointsDefaultValue.productName = 0;
+                  return pointsDefaultValue;
+                }();
+              }
+
+              return outletsItemObject;
+            }();
+          });
+        }();
+      }
+
+      if ('fruitSizes' in jsonObject) {
+        model.fruitSizes = function () {
+          if (Array.isArray(jsonObject['fruitSizes']) !== true) {
+            return [];
+          }
+
+          return jsonObject['fruitSizes'].map(function (fruitSizesItem) {
+            return function () {
+              var fruitSizesItemObject = {};
+
+              if (_typeof(fruitSizesItem) === 'object' && 'fruitSize' in fruitSizesItem) {
+                fruitSizesItemObject.fruitSize = function () {
+                  if (typeof fruitSizesItem.fruitSize !== 'string') {
+                    return String(fruitSizesItem.fruitSize);
+                  }
+
+                  return fruitSizesItem.fruitSize;
+                }();
+              } else {
+                fruitSizesItemObject.fruitSize = "";
+              }
+
+              if (_typeof(fruitSizesItem) === 'object' && 'points' in fruitSizesItem) {
+                fruitSizesItemObject.points = function () {
+                  var pointsObject = {};
+
+                  if (_typeof(fruitSizesItem.points) === 'object' && 'incomingFruitPerMinute' in fruitSizesItem.points) {
+                    pointsObject.incomingFruitPerMinute = function () {
+                      if (typeof fruitSizesItem.points.incomingFruitPerMinute !== 'number') {
+                        return Number.isInteger(Number(fruitSizesItem.points.incomingFruitPerMinute)) ? Number(fruitSizesItem.points.incomingFruitPerMinute) : Math.floor(Number(fruitSizesItem.points.incomingFruitPerMinute));
+                      }
+
+                      return Number.isInteger(fruitSizesItem.points.incomingFruitPerMinute) ? fruitSizesItem.points.incomingFruitPerMinute : Math.floor(fruitSizesItem.points.incomingFruitPerMinute);
+                    }();
+                  } else {
+                    pointsObject.incomingFruitPerMinute = 0;
+                  }
+
+                  if (_typeof(fruitSizesItem.points) === 'object' && 'recycledFruitPerMinute' in fruitSizesItem.points) {
+                    pointsObject.recycledFruitPerMinute = function () {
+                      if (typeof fruitSizesItem.points.recycledFruitPerMinute !== 'number') {
+                        return Number.isInteger(Number(fruitSizesItem.points.recycledFruitPerMinute)) ? Number(fruitSizesItem.points.recycledFruitPerMinute) : Math.floor(Number(fruitSizesItem.points.recycledFruitPerMinute));
+                      }
+
+                      return Number.isInteger(fruitSizesItem.points.recycledFruitPerMinute) ? fruitSizesItem.points.recycledFruitPerMinute : Math.floor(fruitSizesItem.points.recycledFruitPerMinute);
+                    }();
+                  } else {
+                    pointsObject.recycledFruitPerMinute = 0;
+                  }
+
+                  if (_typeof(fruitSizesItem.points) === 'object' && 'allocatedFruitPerMinute' in fruitSizesItem.points) {
+                    pointsObject.allocatedFruitPerMinute = function () {
+                      if (typeof fruitSizesItem.points.allocatedFruitPerMinute !== 'number') {
+                        return Number.isInteger(Number(fruitSizesItem.points.allocatedFruitPerMinute)) ? Number(fruitSizesItem.points.allocatedFruitPerMinute) : Math.floor(Number(fruitSizesItem.points.allocatedFruitPerMinute));
+                      }
+
+                      return Number.isInteger(fruitSizesItem.points.allocatedFruitPerMinute) ? fruitSizesItem.points.allocatedFruitPerMinute : Math.floor(fruitSizesItem.points.allocatedFruitPerMinute);
+                    }();
+                  } else {
+                    pointsObject.allocatedFruitPerMinute = 0;
+                  }
+
+                  return pointsObject;
+                }();
+              } else {
+                fruitSizesItemObject.points = function () {
+                  var pointsDefaultValue = {};
+                  pointsDefaultValue.incomingFruitPerMinute = 0;
+                  pointsDefaultValue.recycledFruitPerMinute = 0;
+                  pointsDefaultValue.allocatedFruitPerMinute = 0;
+                  return pointsDefaultValue;
+                }();
+              }
+
+              return fruitSizesItemObject;
+            }();
+          });
+        }();
+      }
+
+      if ('freshPackIntegration' in jsonObject) {
+        model.freshPackIntegration = function () {
+          if (jsonObject['freshPackIntegration'] === null) {
+            return null;
+          }
+
+          var freshPackIntegrationObject = {};
+
+          if (_typeof(jsonObject['freshPackIntegration']) === 'object' && 'points' in jsonObject['freshPackIntegration']) {
+            freshPackIntegrationObject.points = function () {
+              if (_typeof(jsonObject['freshPackIntegration'].points) !== 'object') {
+                return Object(jsonObject['freshPackIntegration'].points);
+              }
+
+              return jsonObject['freshPackIntegration'].points;
+            }();
+          } else {
+            freshPackIntegrationObject.points = {};
+          }
+
+          if (_typeof(jsonObject['freshPackIntegration']) === 'object' && 'enabled' in jsonObject['freshPackIntegration']) {
+            freshPackIntegrationObject.enabled = function () {
+              if (typeof jsonObject['freshPackIntegration'].enabled !== 'boolean') {
+                return Boolean(jsonObject['freshPackIntegration'].enabled);
+              }
+
+              return jsonObject['freshPackIntegration'].enabled;
+            }();
+          } else {
+            freshPackIntegrationObject.enabled = false;
+          }
+
+          if (_typeof(jsonObject['freshPackIntegration']) === 'object' && 'materialGroupId' in jsonObject['freshPackIntegration']) {
+            freshPackIntegrationObject.materialGroupId = function () {
+              if (typeof jsonObject['freshPackIntegration'].materialGroupId !== 'number') {
+                return Number.isInteger(Number(jsonObject['freshPackIntegration'].materialGroupId)) ? Number(jsonObject['freshPackIntegration'].materialGroupId) : Math.floor(Number(jsonObject['freshPackIntegration'].materialGroupId));
+              }
+
+              return Number.isInteger(jsonObject['freshPackIntegration'].materialGroupId) ? jsonObject['freshPackIntegration'].materialGroupId : Math.floor(jsonObject['freshPackIntegration'].materialGroupId);
+            }();
+          } else {
+            freshPackIntegrationObject.materialGroupId = 0;
+          }
+
+          if (_typeof(jsonObject['freshPackIntegration']) === 'object' && 'binTypeId' in jsonObject['freshPackIntegration']) {
+            freshPackIntegrationObject.binTypeId = function () {
+              if (typeof jsonObject['freshPackIntegration'].binTypeId !== 'number') {
+                return Number.isInteger(Number(jsonObject['freshPackIntegration'].binTypeId)) ? Number(jsonObject['freshPackIntegration'].binTypeId) : Math.floor(Number(jsonObject['freshPackIntegration'].binTypeId));
+              }
+
+              return Number.isInteger(jsonObject['freshPackIntegration'].binTypeId) ? jsonObject['freshPackIntegration'].binTypeId : Math.floor(jsonObject['freshPackIntegration'].binTypeId);
+            }();
+          } else {
+            freshPackIntegrationObject.binTypeId = 0;
+          }
+
+          if (_typeof(jsonObject['freshPackIntegration']) === 'object' && 'bulkWeightClassTypes' in jsonObject['freshPackIntegration']) {
+            freshPackIntegrationObject.bulkWeightClassTypes = function () {
+              if (Array.isArray(jsonObject['freshPackIntegration'].bulkWeightClassTypes) !== true) {
+                return [];
+              }
+
+              return jsonObject['freshPackIntegration'].bulkWeightClassTypes.map(function (bulkWeightClassTypesItem) {
+                return function () {
+                  if (typeof bulkWeightClassTypesItem !== 'string') {
+                    return String(bulkWeightClassTypesItem);
+                  }
+
+                  return bulkWeightClassTypesItem;
+                }();
+              });
+            }();
+          } else {
+            freshPackIntegrationObject.bulkWeightClassTypes = [];
+          }
+
+          return freshPackIntegrationObject;
+        }();
+      }
+
+      if ('reemoonIntegration' in jsonObject) {
+        model.reemoonIntegration = function () {
+          var reemoonIntegrationObject = {};
+
+          if (_typeof(jsonObject['reemoonIntegration']) === 'object' && 'points' in jsonObject['reemoonIntegration']) {
+            reemoonIntegrationObject.points = function () {
+              var pointsObject = {};
+
+              if (_typeof(jsonObject['reemoonIntegration'].points) === 'object' && 'apiCommunicationStatus' in jsonObject['reemoonIntegration'].points) {
+                pointsObject.apiCommunicationStatus = function () {
+                  if (typeof jsonObject['reemoonIntegration'].points.apiCommunicationStatus !== 'number') {
+                    return Number.isInteger(Number(jsonObject['reemoonIntegration'].points.apiCommunicationStatus)) ? Number(jsonObject['reemoonIntegration'].points.apiCommunicationStatus) : Math.floor(Number(jsonObject['reemoonIntegration'].points.apiCommunicationStatus));
+                  }
+
+                  return Number.isInteger(jsonObject['reemoonIntegration'].points.apiCommunicationStatus) ? jsonObject['reemoonIntegration'].points.apiCommunicationStatus : Math.floor(jsonObject['reemoonIntegration'].points.apiCommunicationStatus);
+                }();
+              } else {
+                pointsObject.apiCommunicationStatus = 0;
+              }
+
+              if (_typeof(jsonObject['reemoonIntegration'].points) === 'object' && 'machineId' in jsonObject['reemoonIntegration'].points) {
+                pointsObject.machineId = function () {
+                  if (typeof jsonObject['reemoonIntegration'].points.machineId !== 'number') {
+                    return Number.isInteger(Number(jsonObject['reemoonIntegration'].points.machineId)) ? Number(jsonObject['reemoonIntegration'].points.machineId) : Math.floor(Number(jsonObject['reemoonIntegration'].points.machineId));
+                  }
+
+                  return Number.isInteger(jsonObject['reemoonIntegration'].points.machineId) ? jsonObject['reemoonIntegration'].points.machineId : Math.floor(jsonObject['reemoonIntegration'].points.machineId);
+                }();
+              } else {
+                pointsObject.machineId = 0;
+              }
+
+              if (_typeof(jsonObject['reemoonIntegration'].points) === 'object' && 'machineName' in jsonObject['reemoonIntegration'].points) {
+                pointsObject.machineName = function () {
+                  if (typeof jsonObject['reemoonIntegration'].points.machineName !== 'number') {
+                    return Number.isInteger(Number(jsonObject['reemoonIntegration'].points.machineName)) ? Number(jsonObject['reemoonIntegration'].points.machineName) : Math.floor(Number(jsonObject['reemoonIntegration'].points.machineName));
+                  }
+
+                  return Number.isInteger(jsonObject['reemoonIntegration'].points.machineName) ? jsonObject['reemoonIntegration'].points.machineName : Math.floor(jsonObject['reemoonIntegration'].points.machineName);
+                }();
+              } else {
+                pointsObject.machineName = 0;
+              }
+
+              if (_typeof(jsonObject['reemoonIntegration'].points) === 'object' && 'machineLaneCount' in jsonObject['reemoonIntegration'].points) {
+                pointsObject.machineLaneCount = function () {
+                  if (typeof jsonObject['reemoonIntegration'].points.machineLaneCount !== 'number') {
+                    return Number.isInteger(Number(jsonObject['reemoonIntegration'].points.machineLaneCount)) ? Number(jsonObject['reemoonIntegration'].points.machineLaneCount) : Math.floor(Number(jsonObject['reemoonIntegration'].points.machineLaneCount));
+                  }
+
+                  return Number.isInteger(jsonObject['reemoonIntegration'].points.machineLaneCount) ? jsonObject['reemoonIntegration'].points.machineLaneCount : Math.floor(jsonObject['reemoonIntegration'].points.machineLaneCount);
+                }();
+              } else {
+                pointsObject.machineLaneCount = 0;
+              }
+
+              if (_typeof(jsonObject['reemoonIntegration'].points) === 'object' && 'machineOutletCount' in jsonObject['reemoonIntegration'].points) {
+                pointsObject.machineOutletCount = function () {
+                  if (typeof jsonObject['reemoonIntegration'].points.machineOutletCount !== 'number') {
+                    return Number.isInteger(Number(jsonObject['reemoonIntegration'].points.machineOutletCount)) ? Number(jsonObject['reemoonIntegration'].points.machineOutletCount) : Math.floor(Number(jsonObject['reemoonIntegration'].points.machineOutletCount));
+                  }
+
+                  return Number.isInteger(jsonObject['reemoonIntegration'].points.machineOutletCount) ? jsonObject['reemoonIntegration'].points.machineOutletCount : Math.floor(jsonObject['reemoonIntegration'].points.machineOutletCount);
+                }();
+              } else {
+                pointsObject.machineOutletCount = 0;
+              }
+
+              if (_typeof(jsonObject['reemoonIntegration'].points) === 'object' && 'machineOutletDetails' in jsonObject['reemoonIntegration'].points) {
+                pointsObject.machineOutletDetails = function () {
+                  if (typeof jsonObject['reemoonIntegration'].points.machineOutletDetails !== 'number') {
+                    return Number.isInteger(Number(jsonObject['reemoonIntegration'].points.machineOutletDetails)) ? Number(jsonObject['reemoonIntegration'].points.machineOutletDetails) : Math.floor(Number(jsonObject['reemoonIntegration'].points.machineOutletDetails));
+                  }
+
+                  return Number.isInteger(jsonObject['reemoonIntegration'].points.machineOutletDetails) ? jsonObject['reemoonIntegration'].points.machineOutletDetails : Math.floor(jsonObject['reemoonIntegration'].points.machineOutletDetails);
+                }();
+              } else {
+                pointsObject.machineOutletDetails = 0;
+              }
+
+              return pointsObject;
+            }();
+          } else {
+            reemoonIntegrationObject.points = function () {
+              var pointsDefaultValue = {};
+              pointsDefaultValue.apiCommunicationStatus = 0;
+              pointsDefaultValue.machineId = 0;
+              pointsDefaultValue.machineName = 0;
+              pointsDefaultValue.machineLaneCount = 0;
+              pointsDefaultValue.machineOutletCount = 0;
+              pointsDefaultValue.machineOutletDetails = 0;
+              return pointsDefaultValue;
+            }();
+          }
+
+          if (_typeof(jsonObject['reemoonIntegration']) === 'object' && 'enabled' in jsonObject['reemoonIntegration']) {
+            reemoonIntegrationObject.enabled = function () {
+              if (typeof jsonObject['reemoonIntegration'].enabled !== 'boolean') {
+                return Boolean(jsonObject['reemoonIntegration'].enabled);
+              }
+
+              return jsonObject['reemoonIntegration'].enabled;
+            }();
+          } else {
+            reemoonIntegrationObject.enabled = false;
+          }
+
+          if (_typeof(jsonObject['reemoonIntegration']) === 'object' && 'username' in jsonObject['reemoonIntegration']) {
+            reemoonIntegrationObject.username = function () {
+              if (typeof jsonObject['reemoonIntegration'].username !== 'string') {
+                return String(jsonObject['reemoonIntegration'].username);
+              }
+
+              return jsonObject['reemoonIntegration'].username;
+            }();
+          } else {
+            reemoonIntegrationObject.username = "";
+          }
+
+          if (_typeof(jsonObject['reemoonIntegration']) === 'object' && 'password' in jsonObject['reemoonIntegration']) {
+            reemoonIntegrationObject.password = function () {
+              if (typeof jsonObject['reemoonIntegration'].password !== 'string') {
+                return String(jsonObject['reemoonIntegration'].password);
+              }
+
+              return jsonObject['reemoonIntegration'].password;
+            }();
+          } else {
+            reemoonIntegrationObject.password = "";
+          }
+
+          if (_typeof(jsonObject['reemoonIntegration']) === 'object' && 'apiBaseUrl' in jsonObject['reemoonIntegration']) {
+            reemoonIntegrationObject.apiBaseUrl = function () {
+              if (typeof jsonObject['reemoonIntegration'].apiBaseUrl !== 'string') {
+                return String(jsonObject['reemoonIntegration'].apiBaseUrl);
+              }
+
+              return jsonObject['reemoonIntegration'].apiBaseUrl;
+            }();
+          } else {
+            reemoonIntegrationObject.apiBaseUrl = "";
+          }
+
+          return reemoonIntegrationObject;
+        }();
+      }
+
+      if ('sources' in jsonObject) {
+        model.sources = function () {
+          if (Array.isArray(jsonObject['sources']) !== true) {
+            return [];
+          }
+
+          return jsonObject['sources'].map(function (sourcesItem) {
+            return function () {
+              return sourcesItem;
+            }();
+          });
+        }();
+      }
+
+      if ('productClassTypes' in jsonObject) {
+        model.productClassTypes = function () {
+          if (Array.isArray(jsonObject['productClassTypes']) !== true) {
+            return [];
+          }
+
+          return jsonObject['productClassTypes'].map(function (productClassTypesItem) {
+            return function () {
+              var productClassTypesItemObject = {};
+
+              if (_typeof(productClassTypesItem) === 'object' && 'productName' in productClassTypesItem) {
+                productClassTypesItemObject.productName = function () {
+                  if (typeof productClassTypesItem.productName !== 'string') {
+                    return String(productClassTypesItem.productName);
+                  }
+
+                  return productClassTypesItem.productName;
+                }();
+              } else {
+                productClassTypesItemObject.productName = "";
+              }
+
+              if (_typeof(productClassTypesItem) === 'object' && 'classType' in productClassTypesItem) {
+                productClassTypesItemObject.classType = function () {
+                  if (typeof productClassTypesItem.classType !== 'string') {
+                    return String(productClassTypesItem.classType);
+                  }
+
+                  return productClassTypesItem.classType;
+                }();
+              } else {
+                productClassTypesItemObject.classType = "";
+              }
+
+              if (_typeof(productClassTypesItem) === 'object' && 'matchType' in productClassTypesItem) {
+                productClassTypesItemObject.matchType = function () {
+                  if (typeof productClassTypesItem.matchType !== 'string') {
+                    return String(productClassTypesItem.matchType);
+                  }
+
+                  return productClassTypesItem.matchType;
+                }();
+              } else {
+                productClassTypesItemObject.matchType = "";
+              }
+
+              return productClassTypesItemObject;
+            }();
+          });
+        }();
+      }
+
+      if ('deleted' in jsonObject) {
+        model.deleted = function () {
+          if (typeof jsonObject['deleted'] !== 'boolean') {
+            return Boolean(jsonObject['deleted']);
+          }
+
+          return jsonObject['deleted'];
+        }();
+      }
+
+      if ('updateTimestamp' in jsonObject) {
+        model.updateTimestamp = function () {
+          if (typeof jsonObject['updateTimestamp'] !== 'string') {
+            return new Date(String(jsonObject['updateTimestamp']));
+          }
+
+          return new Date(jsonObject['updateTimestamp']);
+        }();
+      }
+
+      return model;
+    }
+  }]);
+
+  return ReemoonSizerModel;
+}(_BaseModel2.default);
+
+var _default = ReemoonSizerModel;
+exports.default = _default;