@ricado/api-client 2.3.17 → 2.3.18

package/src/Models/Packhouse/Site/MAFSizerModel.js

@@ -50,65 +50,101 @@ class MAFSizerModel extends BaseModel
         this.name = "";
         
         /**
-         * The Lanes defined for this MAF Sizer
+         * The Packing Line ID that manages this MAF Sizer
          * 
-         * @type {Object[]}
+         * @type {string}
          * @public
          */
-        this.lanes = [];
+        this.packingLineId = "";
         
         /**
-         * The Points used by this MAF Sizer
+         * The Sizer Type
          * 
-         * @type {Object}
+         * @type {string}
          * @public
          */
-        this.points = {}
+        this.sizerType = "";
         
         /**
-         * The Outlets defined for this MAF Sizer
+         * The Auto Create Batch Delay in Seconds for this MAF Sizer
          * 
-         * @type {Object[]}
+         * @type {number}
          * @public
          */
-        this.outlets = [];
+        this.autoCreateBatchDelay = 0;
         
         /**
-         * The Sizer Type
+         * The Points used by this MAF Sizer
          * 
-         * @type {string}
+         * @type {{currentBatchId: number, currentBatchName: number, currentBatchGrowerCode: number, currentBatchGrowerName: number, currentBatchVarietyCode: number, currentBatchVarietyName: number, machineAverageFruitWeight: number, machineAverageFruitSize: number, machineCupFill: number, machineRecycledFruitPerMinute: number, machineTotalFruitPerMinute: number, machineTraysPerHour: number, machineTonnesPerHour: number, machineRodsPerMinute: number, outletGroupSummaries: number, packTypeOutletUtilizationTargets: number}}
          * @public
          */
-        this.sizerType = "";
+        this.points = (function(){
+            let pointsDefaultValue = {};
+            
+            pointsDefaultValue.currentBatchId = 0;
+            
+            pointsDefaultValue.currentBatchName = 0;
+            
+            pointsDefaultValue.currentBatchGrowerCode = 0;
+            
+            pointsDefaultValue.currentBatchGrowerName = 0;
+            
+            pointsDefaultValue.currentBatchVarietyCode = 0;
+            
+            pointsDefaultValue.currentBatchVarietyName = 0;
+            
+            pointsDefaultValue.machineAverageFruitWeight = 0;
+            
+            pointsDefaultValue.machineAverageFruitSize = 0;
+            
+            pointsDefaultValue.machineCupFill = 0;
+            
+            pointsDefaultValue.machineRecycledFruitPerMinute = 0;
+            
+            pointsDefaultValue.machineTotalFruitPerMinute = 0;
+            
+            pointsDefaultValue.machineTraysPerHour = 0;
+            
+            pointsDefaultValue.machineTonnesPerHour = 0;
+            
+            pointsDefaultValue.machineRodsPerMinute = 0;
+            
+            pointsDefaultValue.outletGroupSummaries = 0;
+            
+            pointsDefaultValue.packTypeOutletUtilizationTargets = 0;
+            
+            return pointsDefaultValue;
+        }());
         
         /**
-         * The Auto Create Batch Delay in Seconds for this MAF Sizer
+         * The Lanes defined for this MAF Sizer
          * 
-         * @type {number}
+         * @type {Array<{id: string, number: number, points: {cupFill: number}}>}
          * @public
          */
-        this.autoCreateBatchDelay = 0;
+        this.lanes = [];
         
         /**
-         * The Fruit Sizes defined and handled by this MAF Sizer
+         * The Outlets defined for this MAF Sizer
          * 
-         * @type {Object[]}
+         * @type {Array<{id: string, number: number, type: string, points: {name: number, fruitPerMinute: number, articleName: number, utilization: number}}>}
          * @public
          */
-        this.fruitSizes = [];
+        this.outlets = [];
         
         /**
-         * The Packing Line ID that manages this MAF Sizer
+         * The Fruit Sizes defined and handled by this MAF Sizer
          * 
-         * @type {string}
+         * @type {Array<{fruitSize: string, points: {incomingFruitPerMinute: number, recycledFruitPerMinute: number, allocatedFruitPerMinute: number}}>}
          * @public
          */
-        this.packingLineId = "";
+        this.fruitSizes = [];
         
         /**
          * The FreshPack Integration Configuration for this MAF Sizer
          * 
-         * @type {?Object}
+         * @type {?{points: Object, enabled: boolean, materialGroupId: number, binTypeId: number, bulkWeightClassTypes: string[]}}
          * @public
          */
         this.freshPackIntegration = null;
@@ -116,7 +152,7 @@ class MAFSizerModel extends BaseModel
         /**
          * The MAF Integration Configuration for this MAF Sizer
          * 
-         * @type {?Object}
+         * @type {?{points: {stopBatchRequired: number}, enabled: boolean, sizerNumber: number, dumpSizerName: string, statSizerName: string}}
          * @public
          */
         this.mafIntegration = null;
@@ -124,7 +160,7 @@ class MAFSizerModel extends BaseModel
         /**
          * An Array of Sources that deliver Fruit to this MAF Sizer
          * 
-         * @type {Object[]}
+         * @type {{type: string, riserId: string}|{type: string, sizerId: string, outletNumbers: number[]}[]}
          * @public
          */
         this.sources = [];
@@ -132,7 +168,7 @@ class MAFSizerModel extends BaseModel
         /**
          * An Array of Article to Class Type Maps for this MAF Sizer
          * 
-         * @type {Object[]}
+         * @type {Array<{articleName: string, classType: string}>}
          * @public
          */
         this.articleClassTypes = [];
@@ -232,114 +268,649 @@ class MAFSizerModel extends BaseModel
             }());
         }
         
-        if('lanes' in jsonObject)
+        if('packingLineId' in jsonObject)
         {
-            model.lanes = (function(){
-                if(Array.isArray(jsonObject['lanes']) !== true)
+            model.packingLineId = (function(){
+                if(typeof jsonObject['packingLineId'] !== 'string')
                 {
-                    return [];
+                    return String(jsonObject['packingLineId']);
                 }
         
-                return jsonObject['lanes'].map((lanesItem) => {
-                    return (function(){
-                        if(typeof lanesItem !== 'object')
-                        {
-                            return Object(lanesItem);
-                        }
+                return jsonObject['packingLineId'];
+            }());
+        }
         
-                        return lanesItem;
-                    }());
-                });
+        if('sizerType' in jsonObject)
+        {
+            model.sizerType = (function(){
+                if(typeof jsonObject['sizerType'] !== 'string')
+                {
+                    return String(jsonObject['sizerType']);
+                }
+        
+                return jsonObject['sizerType'];
             }());
         }
         
-        if('points' in jsonObject)
+        if('autoCreateBatchDelay' in jsonObject)
         {
-            model.points = (function(){
-                if(typeof jsonObject['points'] !== 'object')
+            model.autoCreateBatchDelay = (function(){
+                if(typeof jsonObject['autoCreateBatchDelay'] !== 'number')
                 {
-                    return Object(jsonObject['points']);
+                    return Number.isInteger(Number(jsonObject['autoCreateBatchDelay'])) ? Number(jsonObject['autoCreateBatchDelay']) : Math.floor(Number(jsonObject['autoCreateBatchDelay']));
                 }
         
-                return jsonObject['points'];
+                return Number.isInteger(jsonObject['autoCreateBatchDelay']) ? jsonObject['autoCreateBatchDelay'] : Math.floor(jsonObject['autoCreateBatchDelay']);
             }());
         }
         
-        if('outlets' in jsonObject)
+        if('points' in jsonObject)
         {
-            model.outlets = (function(){
-                if(Array.isArray(jsonObject['outlets']) !== true)
+            model.points = (function(){
+                let pointsObject = {};
+                
+                if(typeof jsonObject['points'] === 'object' && 'currentBatchId' in jsonObject['points'])
                 {
-                    return [];
+                    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 jsonObject['outlets'].map((outletsItem) => {
-                    return (function(){
-                        if(typeof outletsItem !== 'object')
+                        return Number.isInteger(jsonObject['points'].currentBatchName) ? jsonObject['points'].currentBatchName : Math.floor(jsonObject['points'].currentBatchName);
+                    }());
+                }
+                else
+                {
+                    pointsObject.currentBatchName = 0;
+                }
+                
+                if(typeof jsonObject['points'] === 'object' && 'currentBatchGrowerCode' in jsonObject['points'])
+                {
+                    pointsObject.currentBatchGrowerCode = (function(){
+                        if(typeof jsonObject['points'].currentBatchGrowerCode !== 'number')
                         {
-                            return Object(outletsItem);
+                            return Number.isInteger(Number(jsonObject['points'].currentBatchGrowerCode)) ? Number(jsonObject['points'].currentBatchGrowerCode) : Math.floor(Number(jsonObject['points'].currentBatchGrowerCode));
                         }
         
-                        return outletsItem;
+                        return Number.isInteger(jsonObject['points'].currentBatchGrowerCode) ? jsonObject['points'].currentBatchGrowerCode : Math.floor(jsonObject['points'].currentBatchGrowerCode);
                     }());
-                });
-            }());
-        }
+                }
+                else
+                {
+                    pointsObject.currentBatchGrowerCode = 0;
+                }
+                
+                if(typeof jsonObject['points'] === 'object' && 'currentBatchGrowerName' in jsonObject['points'])
+                {
+                    pointsObject.currentBatchGrowerName = (function(){
+                        if(typeof jsonObject['points'].currentBatchGrowerName !== 'number')
+                        {
+                            return Number.isInteger(Number(jsonObject['points'].currentBatchGrowerName)) ? Number(jsonObject['points'].currentBatchGrowerName) : Math.floor(Number(jsonObject['points'].currentBatchGrowerName));
+                        }
         
-        if('sizerType' in jsonObject)
-        {
-            model.sizerType = (function(){
-                if(typeof jsonObject['sizerType'] !== 'string')
+                        return Number.isInteger(jsonObject['points'].currentBatchGrowerName) ? jsonObject['points'].currentBatchGrowerName : Math.floor(jsonObject['points'].currentBatchGrowerName);
+                    }());
+                }
+                else
                 {
-                    return String(jsonObject['sizerType']);
+                    pointsObject.currentBatchGrowerName = 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 jsonObject['sizerType'];
+                        return Number.isInteger(jsonObject['points'].currentBatchVarietyCode) ? jsonObject['points'].currentBatchVarietyCode : Math.floor(jsonObject['points'].currentBatchVarietyCode);
+                    }());
+                }
+                else
+                {
+                    pointsObject.currentBatchVarietyCode = 0;
+                }
+                
+                if(typeof jsonObject['points'] === 'object' && 'currentBatchVarietyName' in jsonObject['points'])
+                {
+                    pointsObject.currentBatchVarietyName = (function(){
+                        if(typeof jsonObject['points'].currentBatchVarietyName !== 'number')
+                        {
+                            return Number.isInteger(Number(jsonObject['points'].currentBatchVarietyName)) ? Number(jsonObject['points'].currentBatchVarietyName) : Math.floor(Number(jsonObject['points'].currentBatchVarietyName));
+                        }
+        
+                        return Number.isInteger(jsonObject['points'].currentBatchVarietyName) ? jsonObject['points'].currentBatchVarietyName : Math.floor(jsonObject['points'].currentBatchVarietyName);
+                    }());
+                }
+                else
+                {
+                    pointsObject.currentBatchVarietyName = 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' && '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' && 'machineTotalFruitPerMinute' in jsonObject['points'])
+                {
+                    pointsObject.machineTotalFruitPerMinute = (function(){
+                        if(typeof jsonObject['points'].machineTotalFruitPerMinute !== 'number')
+                        {
+                            return Number.isInteger(Number(jsonObject['points'].machineTotalFruitPerMinute)) ? Number(jsonObject['points'].machineTotalFruitPerMinute) : Math.floor(Number(jsonObject['points'].machineTotalFruitPerMinute));
+                        }
+        
+                        return Number.isInteger(jsonObject['points'].machineTotalFruitPerMinute) ? jsonObject['points'].machineTotalFruitPerMinute : Math.floor(jsonObject['points'].machineTotalFruitPerMinute);
+                    }());
+                }
+                else
+                {
+                    pointsObject.machineTotalFruitPerMinute = 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' && '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' && '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;
+                }
+        
+                return pointsObject;
             }());
         }
         
-        if('autoCreateBatchDelay' in jsonObject)
+        if('lanes' in jsonObject)
         {
-            model.autoCreateBatchDelay = (function(){
-                if(typeof jsonObject['autoCreateBatchDelay'] !== 'number')
+            model.lanes = (function(){
+                if(Array.isArray(jsonObject['lanes']) !== true)
                 {
-                    return Number.isInteger(Number(jsonObject['autoCreateBatchDelay'])) ? Number(jsonObject['autoCreateBatchDelay']) : Math.floor(Number(jsonObject['autoCreateBatchDelay']));
+                    return [];
                 }
         
-                return Number.isInteger(jsonObject['autoCreateBatchDelay']) ? jsonObject['autoCreateBatchDelay'] : Math.floor(jsonObject['autoCreateBatchDelay']);
+                return jsonObject['lanes'].map((lanesItem) => {
+                    return (function(){
+                        let 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(){
+                                let 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(){
+                                let pointsDefaultValue = {};
+                                
+                                pointsDefaultValue.cupFill = 0;
+                                
+                                return pointsDefaultValue;
+                            }());
+                        }
+        
+                        return lanesItemObject;
+                    }());
+                });
             }());
         }
         
-        if('fruitSizes' in jsonObject)
+        if('outlets' in jsonObject)
         {
-            model.fruitSizes = (function(){
-                if(Array.isArray(jsonObject['fruitSizes']) !== true)
+            model.outlets = (function(){
+                if(Array.isArray(jsonObject['outlets']) !== true)
                 {
                     return [];
                 }
         
-                return jsonObject['fruitSizes'].map((fruitSizesItem) => {
+                return jsonObject['outlets'].map((outletsItem) => {
                     return (function(){
-                        if(typeof fruitSizesItem !== 'object')
+                        let outletsItemObject = {};
+                        
+                        if(typeof outletsItem === 'object' && 'id' in outletsItem)
                         {
-                            return Object(fruitSizesItem);
+                            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(){
+                                let 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' && 'articleName' in outletsItem.points)
+                                {
+                                    pointsObject.articleName = (function(){
+                                        if(typeof outletsItem.points.articleName !== 'number')
+                                        {
+                                            return Number.isInteger(Number(outletsItem.points.articleName)) ? Number(outletsItem.points.articleName) : Math.floor(Number(outletsItem.points.articleName));
+                                        }
+        
+                                        return Number.isInteger(outletsItem.points.articleName) ? outletsItem.points.articleName : Math.floor(outletsItem.points.articleName);
+                                    }());
+                                }
+                                else
+                                {
+                                    pointsObject.articleName = 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;
+                                }
+        
+                                return pointsObject;
+                            }());
+                        }
+                        else
+                        {
+                            outletsItemObject.points = (function(){
+                                let pointsDefaultValue = {};
+                                
+                                pointsDefaultValue.name = 0;
+                                
+                                pointsDefaultValue.fruitPerMinute = 0;
+                                
+                                pointsDefaultValue.articleName = 0;
+                                
+                                pointsDefaultValue.utilization = 0;
+                                
+                                return pointsDefaultValue;
+                            }());
                         }
         
-                        return fruitSizesItem;
+                        return outletsItemObject;
                     }());
                 });
             }());
         }
         
-        if('packingLineId' in jsonObject)
+        if('fruitSizes' in jsonObject)
         {
-            model.packingLineId = (function(){
-                if(typeof jsonObject['packingLineId'] !== 'string')
+            model.fruitSizes = (function(){
+                if(Array.isArray(jsonObject['fruitSizes']) !== true)
                 {
-                    return String(jsonObject['packingLineId']);
+                    return [];
                 }
         
-                return jsonObject['packingLineId'];
+                return jsonObject['fruitSizes'].map((fruitSizesItem) => {
+                    return (function(){
+                        let 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(){
+                                let 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(){
+                                let pointsDefaultValue = {};
+                                
+                                pointsDefaultValue.incomingFruitPerMinute = 0;
+                                
+                                pointsDefaultValue.recycledFruitPerMinute = 0;
+                                
+                                pointsDefaultValue.allocatedFruitPerMinute = 0;
+                                
+                                return pointsDefaultValue;
+                            }());
+                        }
+        
+                        return fruitSizesItemObject;
+                    }());
+                });
             }());
         }
         
@@ -351,12 +922,98 @@ class MAFSizerModel extends BaseModel
                     return null;
                 }
         
-                if(typeof jsonObject['freshPackIntegration'] !== 'object')
+                let 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
                 {
-                    return Object(jsonObject['freshPackIntegration']);
+                    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 jsonObject['freshPackIntegration'];
+                        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((bulkWeightClassTypesItem) => {
+                            return (function(){
+                                if(typeof bulkWeightClassTypesItem !== 'string')
+                                {
+                                    return String(bulkWeightClassTypesItem);
+                                }
+        
+                                return bulkWeightClassTypesItem;
+                            }());
+                        });
+                    }());
+                }
+                else
+                {
+                    freshPackIntegrationObject.bulkWeightClassTypes = [];
+                }
+        
+                return freshPackIntegrationObject;
             }());
         }
         
@@ -368,12 +1025,108 @@ class MAFSizerModel extends BaseModel
                     return null;
                 }
         
-                if(typeof jsonObject['mafIntegration'] !== 'object')
+                let mafIntegrationObject = {};
+                
+                if(typeof jsonObject['mafIntegration'] === 'object' && 'points' in jsonObject['mafIntegration'])
+                {
+                    mafIntegrationObject.points = (function(){
+                        let pointsObject = {};
+                        
+                        if(typeof jsonObject['mafIntegration'].points === 'object' && 'stopBatchRequired' in jsonObject['mafIntegration'].points)
+                        {
+                            pointsObject.stopBatchRequired = (function(){
+                                if(typeof jsonObject['mafIntegration'].points.stopBatchRequired !== 'number')
+                                {
+                                    return Number.isInteger(Number(jsonObject['mafIntegration'].points.stopBatchRequired)) ? Number(jsonObject['mafIntegration'].points.stopBatchRequired) : Math.floor(Number(jsonObject['mafIntegration'].points.stopBatchRequired));
+                                }
+        
+                                return Number.isInteger(jsonObject['mafIntegration'].points.stopBatchRequired) ? jsonObject['mafIntegration'].points.stopBatchRequired : Math.floor(jsonObject['mafIntegration'].points.stopBatchRequired);
+                            }());
+                        }
+                        else
+                        {
+                            pointsObject.stopBatchRequired = 0;
+                        }
+        
+                        return pointsObject;
+                    }());
+                }
+                else
+                {
+                    mafIntegrationObject.points = (function(){
+                        let pointsDefaultValue = {};
+                        
+                        pointsDefaultValue.stopBatchRequired = 0;
+                        
+                        return pointsDefaultValue;
+                    }());
+                }
+                
+                if(typeof jsonObject['mafIntegration'] === 'object' && 'enabled' in jsonObject['mafIntegration'])
+                {
+                    mafIntegrationObject.enabled = (function(){
+                        if(typeof jsonObject['mafIntegration'].enabled !== 'boolean')
+                        {
+                            return Boolean(jsonObject['mafIntegration'].enabled);
+                        }
+        
+                        return jsonObject['mafIntegration'].enabled;
+                    }());
+                }
+                else
+                {
+                    mafIntegrationObject.enabled = false;
+                }
+                
+                if(typeof jsonObject['mafIntegration'] === 'object' && 'sizerNumber' in jsonObject['mafIntegration'])
+                {
+                    mafIntegrationObject.sizerNumber = (function(){
+                        if(typeof jsonObject['mafIntegration'].sizerNumber !== 'number')
+                        {
+                            return Number(jsonObject['mafIntegration'].sizerNumber);
+                        }
+        
+                        return jsonObject['mafIntegration'].sizerNumber;
+                    }());
+                }
+                else
                 {
-                    return Object(jsonObject['mafIntegration']);
+                    mafIntegrationObject.sizerNumber = 0;
                 }
+                
+                if(typeof jsonObject['mafIntegration'] === 'object' && 'dumpSizerName' in jsonObject['mafIntegration'])
+                {
+                    mafIntegrationObject.dumpSizerName = (function(){
+                        if(typeof jsonObject['mafIntegration'].dumpSizerName !== 'string')
+                        {
+                            return String(jsonObject['mafIntegration'].dumpSizerName);
+                        }
         
-                return jsonObject['mafIntegration'];
+                        return jsonObject['mafIntegration'].dumpSizerName;
+                    }());
+                }
+                else
+                {
+                    mafIntegrationObject.dumpSizerName = "";
+                }
+                
+                if(typeof jsonObject['mafIntegration'] === 'object' && 'statSizerName' in jsonObject['mafIntegration'])
+                {
+                    mafIntegrationObject.statSizerName = (function(){
+                        if(typeof jsonObject['mafIntegration'].statSizerName !== 'string')
+                        {
+                            return String(jsonObject['mafIntegration'].statSizerName);
+                        }
+        
+                        return jsonObject['mafIntegration'].statSizerName;
+                    }());
+                }
+                else
+                {
+                    mafIntegrationObject.statSizerName = "";
+                }
+        
+                return mafIntegrationObject;
             }());
         }
         
@@ -387,11 +1140,6 @@ class MAFSizerModel extends BaseModel
         
                 return jsonObject['sources'].map((sourcesItem) => {
                     return (function(){
-                        if(typeof sourcesItem !== 'object')
-                        {
-                            return Object(sourcesItem);
-                        }
-        
                         return sourcesItem;
                     }());
                 });
@@ -408,12 +1156,41 @@ class MAFSizerModel extends BaseModel
         
                 return jsonObject['articleClassTypes'].map((articleClassTypesItem) => {
                     return (function(){
-                        if(typeof articleClassTypesItem !== 'object')
+                        let articleClassTypesItemObject = {};
+                        
+                        if(typeof articleClassTypesItem === 'object' && 'articleName' in articleClassTypesItem)
+                        {
+                            articleClassTypesItemObject.articleName = (function(){
+                                if(typeof articleClassTypesItem.articleName !== 'string')
+                                {
+                                    return String(articleClassTypesItem.articleName);
+                                }
+        
+                                return articleClassTypesItem.articleName;
+                            }());
+                        }
+                        else
+                        {
+                            articleClassTypesItemObject.articleName = "";
+                        }
+                        
+                        if(typeof articleClassTypesItem === 'object' && 'classType' in articleClassTypesItem)
+                        {
+                            articleClassTypesItemObject.classType = (function(){
+                                if(typeof articleClassTypesItem.classType !== 'string')
+                                {
+                                    return String(articleClassTypesItem.classType);
+                                }
+        
+                                return articleClassTypesItem.classType;
+                            }());
+                        }
+                        else
                         {
-                            return Object(articleClassTypesItem);
+                            articleClassTypesItemObject.classType = "";
                         }
         
-                        return articleClassTypesItem;
+                        return articleClassTypesItemObject;
                     }());
                 });
             }());