initialize

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/BoardProcessedDataMapper.cs

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class BoardProcessedDataMapper:StationBaseMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData get(BoardProcessedData itacBoardProcessedData)
+         {
+            if (itacBoardProcessedData == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData asmBoardProcessedData = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData();
+            mapItac2Asm(asmBoardProcessedData, itacBoardProcessedData);
+            return asmBoardProcessedData;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData asmBoardProcessedData, BoardProcessedData itacBoardProcessedData)
+      {
+         // skip readonly property ProcessedBoards
+         // skip readonly property StationEvents
+         // skip readonly property UsedDetails
+         // skip readonly property PickupErrors
+         // skip readonly property Recipe
+         // complex property ContentSummaryType, isArray:False, isGeneric:False
+         asmBoardProcessedData.ContentSummaryType = com.itac.oib.monitoring.contracts.data.ContentSummaryTypeMapper.get( itacBoardProcessedData.ContentSummaryType);
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData[] get(BoardProcessedData[] itacBoardProcessedData)
+      {
+         if (itacBoardProcessedData == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData[] asmBoardProcessedData = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData[itacBoardProcessedData.Length];
+         for (int i = 0; i < itacBoardProcessedData.Length; i++)
+         {
+            // to itac array
+            asmBoardProcessedData[i] = BoardProcessedDataMapper.get(itacBoardProcessedData[i]);
+         }
+         return asmBoardProcessedData;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData> getList(BoardProcessedData[] asmBoardProcessedData)
+      {
+         if (asmBoardProcessedData == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData> itacBoardProcessedData = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData>();
+         for (int i = 0; i < asmBoardProcessedData.Length; i++)
+         {
+            itacBoardProcessedData.Add(BoardProcessedDataMapper.get(asmBoardProcessedData[i]));
+         }
+         return itacBoardProcessedData;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static BoardProcessedData get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData asmBoardProcessedData)
+      {
+         if (asmBoardProcessedData == null) { return null; }
+         BoardProcessedData itacBoardProcessedData = new BoardProcessedData();
+         mapAsm2Itac(asmBoardProcessedData, itacBoardProcessedData);
+         return itacBoardProcessedData;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData asmBoardProcessedData, BoardProcessedData itacBoardProcessedData)
+      {
+         StationBaseMapper.mapAsm2Itac(asmBoardProcessedData, itacBoardProcessedData);
+         // maps ASM list 2 iTAC array
+         itacBoardProcessedData.ProcessedBoards = ProcessedBoardMapper.getArray(asmBoardProcessedData.ProcessedBoards);
+         // maps ASM list 2 iTAC array
+         itacBoardProcessedData.StationEvents = StationEventMapper.getArray(asmBoardProcessedData.StationEvents);
+         // maps ASM list 2 iTAC array
+         itacBoardProcessedData.UsedDetails = UsedDetailMapper.getArray(asmBoardProcessedData.UsedDetails);
+         // maps ASM list 2 iTAC array
+         itacBoardProcessedData.PickupErrors = PickupErrorMapper.getArray(asmBoardProcessedData.PickupErrors);
+         itacBoardProcessedData.Recipe = com.itac.oib.monitoring.contracts.data.RecipeMapper.get(asmBoardProcessedData.Recipe);
+         // complex asm property Recipe
+         itacBoardProcessedData.ContentSummaryType = com.itac.oib.monitoring.contracts.data.ContentSummaryTypeMapper.get(asmBoardProcessedData.ContentSummaryType);
+         // complex asm property ContentSummaryType
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static BoardProcessedData[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData> asmBoardProcessedData)
+      {
+         if (asmBoardProcessedData == null) { return null; }
+         BoardProcessedData[] itacBoardProcessedData = new BoardProcessedData[asmBoardProcessedData.Count];
+         for (int i = 0; i < asmBoardProcessedData.Count; i++)
+         {
+            itacBoardProcessedData[i] = BoardProcessedDataMapper.get(asmBoardProcessedData[i]);
+         }
+         return itacBoardProcessedData;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static BoardProcessedData[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.BoardProcessedData[] asmBoardProcessedData)
+      {
+         if (asmBoardProcessedData == null) { return null; }
+         BoardProcessedData[] itacBoardProcessedData = new BoardProcessedData[asmBoardProcessedData.Length];
+         for (int i = 0; i < asmBoardProcessedData.Length; i++)
+         {
+            itacBoardProcessedData[i] = BoardProcessedDataMapper.get(asmBoardProcessedData[i]);
+         }
+         return itacBoardProcessedData;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/BoardSideTypeMapper.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:59
+using System;
+using System.Collections.Generic;
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class BoardSideTypeMapper
+   {
+
+      // map asm enum value to itac enum value
+      public static BoardSideType get(Asm.As.Oib.Monitoring.Proxy.Business.Types.BoardSideType boardSideType)
+      {
+         int intValue = (int)boardSideType;
+         return (BoardSideType)intValue;
+      }
+
+      // map itac enum value to ASM enum value
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Types.BoardSideType get(BoardSideType boardSideType)
+      {
+         int intValue = (int)boardSideType;
+         return (Asm.As.Oib.Monitoring.Proxy.Business.Types.BoardSideType)intValue;
+      }
+   }
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/BoardStatusTypeMapper.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:59
+using System;
+using System.Collections.Generic;
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class BoardStatusTypeMapper
+   {
+
+      // map asm enum value to itac enum value
+      public static BoardStatusType get(Asm.As.Oib.Monitoring.Proxy.Business.Types.BoardStatusType boardStatusType)
+      {
+         int intValue = (int)boardStatusType;
+         return (BoardStatusType)intValue;
+      }
+
+      // map itac enum value to ASM enum value
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Types.BoardStatusType get(BoardStatusType boardStatusType)
+      {
+         int intValue = (int)boardStatusType;
+         return (Asm.As.Oib.Monitoring.Proxy.Business.Types.BoardStatusType)intValue;
+      }
+   }
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/CompletionStatusTypeMapper.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:59
+using System;
+using System.Collections.Generic;
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class CompletionStatusTypeMapper
+   {
+
+      // map asm enum value to itac enum value
+      public static CompletionStatusType get(Asm.As.Oib.Monitoring.Proxy.Business.Types.CompletionStatusType completionStatusType)
+      {
+         int intValue = (int)completionStatusType;
+         return (CompletionStatusType)intValue;
+      }
+
+      // map itac enum value to ASM enum value
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Types.CompletionStatusType get(CompletionStatusType completionStatusType)
+      {
+         int intValue = (int)completionStatusType;
+         return (Asm.As.Oib.Monitoring.Proxy.Business.Types.CompletionStatusType)intValue;
+      }
+   }
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/ConfigurationMapper.cs

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class ConfigurationMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration get(Configuration itacConfiguration)
+         {
+            if (itacConfiguration == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration asmConfiguration = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration();
+            mapItac2Asm(asmConfiguration, itacConfiguration);
+            return asmConfiguration;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration asmConfiguration, Configuration itacConfiguration)
+      {
+         // skip readonly property Lines
+         // skip readonly property HostName
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration[] get(Configuration[] itacConfiguration)
+      {
+         if (itacConfiguration == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration[] asmConfiguration = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration[itacConfiguration.Length];
+         for (int i = 0; i < itacConfiguration.Length; i++)
+         {
+            // to itac array
+            asmConfiguration[i] = ConfigurationMapper.get(itacConfiguration[i]);
+         }
+         return asmConfiguration;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration> getList(Configuration[] asmConfiguration)
+      {
+         if (asmConfiguration == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration> itacConfiguration = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration>();
+         for (int i = 0; i < asmConfiguration.Length; i++)
+         {
+            itacConfiguration.Add(ConfigurationMapper.get(asmConfiguration[i]));
+         }
+         return itacConfiguration;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static Configuration get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration asmConfiguration)
+      {
+         if (asmConfiguration == null) { return null; }
+         Configuration itacConfiguration = new Configuration();
+         mapAsm2Itac(asmConfiguration, itacConfiguration);
+         return itacConfiguration;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration asmConfiguration, Configuration itacConfiguration)
+      {
+         // maps ASM list 2 iTAC array
+         itacConfiguration.Lines = LineMapper.getArray(asmConfiguration.Lines);
+         itacConfiguration.HostName = asmConfiguration.HostName;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static Configuration[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration> asmConfiguration)
+      {
+         if (asmConfiguration == null) { return null; }
+         Configuration[] itacConfiguration = new Configuration[asmConfiguration.Count];
+         for (int i = 0; i < asmConfiguration.Count; i++)
+         {
+            itacConfiguration[i] = ConfigurationMapper.get(asmConfiguration[i]);
+         }
+         return itacConfiguration;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static Configuration[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Configuration[] asmConfiguration)
+      {
+         if (asmConfiguration == null) { return null; }
+         Configuration[] itacConfiguration = new Configuration[asmConfiguration.Length];
+         for (int i = 0; i < asmConfiguration.Length; i++)
+         {
+            itacConfiguration[i] = ConfigurationMapper.get(asmConfiguration[i]);
+         }
+         return itacConfiguration;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/ContentSummaryTypeMapper.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:59
+using System;
+using System.Collections.Generic;
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class ContentSummaryTypeMapper
+   {
+
+      // map asm enum value to itac enum value
+      public static ContentSummaryType get(Asm.As.Oib.Monitoring.Proxy.Business.Types.ContentSummaryType contentSummaryType)
+      {
+         int intValue = (int)contentSummaryType;
+         return (ContentSummaryType)intValue;
+      }
+
+      // map itac enum value to ASM enum value
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Types.ContentSummaryType get(ContentSummaryType contentSummaryType)
+      {
+         int intValue = (int)contentSummaryType;
+         return (Asm.As.Oib.Monitoring.Proxy.Business.Types.ContentSummaryType)intValue;
+      }
+   }
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/ConveyorTypeMapper.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:59
+using System;
+using System.Collections.Generic;
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class ConveyorTypeMapper
+   {
+
+      // map asm enum value to itac enum value
+      public static ConveyorType get(Asm.As.Oib.Monitoring.Proxy.Business.Types.ConveyorType conveyorType)
+      {
+         int intValue = (int)conveyorType;
+         return (ConveyorType)intValue;
+      }
+
+      // map itac enum value to ASM enum value
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Types.ConveyorType get(ConveyorType conveyorType)
+      {
+         int intValue = (int)conveyorType;
+         return (Asm.As.Oib.Monitoring.Proxy.Business.Types.ConveyorType)intValue;
+      }
+   }
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/DownloadRecipeMapper.cs

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class DownloadRecipeMapper:MonitoringDataMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe get(DownloadRecipe itacDownloadRecipe)
+         {
+            if (itacDownloadRecipe == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe asmDownloadRecipe = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe();
+            mapItac2Asm(asmDownloadRecipe, itacDownloadRecipe);
+            return asmDownloadRecipe;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe asmDownloadRecipe, DownloadRecipe itacDownloadRecipe)
+      {
+         // skip readonly property Recipe
+         // skip readonly property DownloadTime
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe[] get(DownloadRecipe[] itacDownloadRecipe)
+      {
+         if (itacDownloadRecipe == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe[] asmDownloadRecipe = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe[itacDownloadRecipe.Length];
+         for (int i = 0; i < itacDownloadRecipe.Length; i++)
+         {
+            // to itac array
+            asmDownloadRecipe[i] = DownloadRecipeMapper.get(itacDownloadRecipe[i]);
+         }
+         return asmDownloadRecipe;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe> getList(DownloadRecipe[] asmDownloadRecipe)
+      {
+         if (asmDownloadRecipe == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe> itacDownloadRecipe = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe>();
+         for (int i = 0; i < asmDownloadRecipe.Length; i++)
+         {
+            itacDownloadRecipe.Add(DownloadRecipeMapper.get(asmDownloadRecipe[i]));
+         }
+         return itacDownloadRecipe;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static DownloadRecipe get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe asmDownloadRecipe)
+      {
+         if (asmDownloadRecipe == null) { return null; }
+         DownloadRecipe itacDownloadRecipe = new DownloadRecipe();
+         mapAsm2Itac(asmDownloadRecipe, itacDownloadRecipe);
+         return itacDownloadRecipe;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe asmDownloadRecipe, DownloadRecipe itacDownloadRecipe)
+      {
+         MonitoringDataMapper.mapAsm2Itac(asmDownloadRecipe, itacDownloadRecipe);
+         itacDownloadRecipe.Recipe = com.itac.oib.monitoring.contracts.data.RecipeMapper.get(asmDownloadRecipe.Recipe);
+         // complex asm property Recipe
+         itacDownloadRecipe.DownloadTime = asmDownloadRecipe.DownloadTime;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static DownloadRecipe[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe> asmDownloadRecipe)
+      {
+         if (asmDownloadRecipe == null) { return null; }
+         DownloadRecipe[] itacDownloadRecipe = new DownloadRecipe[asmDownloadRecipe.Count];
+         for (int i = 0; i < asmDownloadRecipe.Count; i++)
+         {
+            itacDownloadRecipe[i] = DownloadRecipeMapper.get(asmDownloadRecipe[i]);
+         }
+         return itacDownloadRecipe;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static DownloadRecipe[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.DownloadRecipe[] asmDownloadRecipe)
+      {
+         if (asmDownloadRecipe == null) { return null; }
+         DownloadRecipe[] itacDownloadRecipe = new DownloadRecipe[asmDownloadRecipe.Length];
+         for (int i = 0; i < asmDownloadRecipe.Length; i++)
+         {
+            itacDownloadRecipe[i] = DownloadRecipeMapper.get(asmDownloadRecipe[i]);
+         }
+         return itacDownloadRecipe;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/GantryEventTypeMapper.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:59
+using System;
+using System.Collections.Generic;
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class GantryEventTypeMapper
+   {
+
+      // map asm enum value to itac enum value
+      public static GantryEventType get(Asm.As.Oib.Monitoring.Proxy.Business.Types.GantryEventType gantryEventType)
+      {
+         int intValue = (int)gantryEventType;
+         return (GantryEventType)intValue;
+      }
+
+      // map itac enum value to ASM enum value
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Types.GantryEventType get(GantryEventType gantryEventType)
+      {
+         int intValue = (int)gantryEventType;
+         return (Asm.As.Oib.Monitoring.Proxy.Business.Types.GantryEventType)intValue;
+      }
+   }
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/GantryStateMapper.cs

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class GantryStateMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState get(GantryState itacGantryState)
+         {
+            if (itacGantryState == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState asmGantryState = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState();
+            mapItac2Asm(asmGantryState, itacGantryState);
+            return asmGantryState;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState asmGantryState, GantryState itacGantryState)
+      {
+         // complex property State, isArray:False, isGeneric:False
+         asmGantryState.State = com.itac.oib.monitoring.contracts.data.GantryEventTypeMapper.get( itacGantryState.State);
+         asmGantryState.GantryNumber = itacGantryState.GantryNumber;
+         asmGantryState.ProcessingArea = itacGantryState.ProcessingArea;
+         asmGantryState.ErrorReason = itacGantryState.ErrorReason;
+         asmGantryState.BoardNumber = itacGantryState.BoardNumber;
+         asmGantryState.StationTime = itacGantryState.StationTime;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState[] get(GantryState[] itacGantryState)
+      {
+         if (itacGantryState == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState[] asmGantryState = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState[itacGantryState.Length];
+         for (int i = 0; i < itacGantryState.Length; i++)
+         {
+            // to itac array
+            asmGantryState[i] = GantryStateMapper.get(itacGantryState[i]);
+         }
+         return asmGantryState;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState> getList(GantryState[] asmGantryState)
+      {
+         if (asmGantryState == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState> itacGantryState = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState>();
+         for (int i = 0; i < asmGantryState.Length; i++)
+         {
+            itacGantryState.Add(GantryStateMapper.get(asmGantryState[i]));
+         }
+         return itacGantryState;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static GantryState get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState asmGantryState)
+      {
+         if (asmGantryState == null) { return null; }
+         GantryState itacGantryState = new GantryState();
+         mapAsm2Itac(asmGantryState, itacGantryState);
+         return itacGantryState;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState asmGantryState, GantryState itacGantryState)
+      {
+         itacGantryState.State = com.itac.oib.monitoring.contracts.data.GantryEventTypeMapper.get(asmGantryState.State);
+         // complex asm property State
+         itacGantryState.GantryNumber = asmGantryState.GantryNumber;
+         itacGantryState.ProcessingArea = asmGantryState.ProcessingArea;
+         itacGantryState.ErrorReason = asmGantryState.ErrorReason;
+         itacGantryState.BoardNumber = asmGantryState.BoardNumber;
+         itacGantryState.StationTime = asmGantryState.StationTime;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static GantryState[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState> asmGantryState)
+      {
+         if (asmGantryState == null) { return null; }
+         GantryState[] itacGantryState = new GantryState[asmGantryState.Count];
+         for (int i = 0; i < asmGantryState.Count; i++)
+         {
+            itacGantryState[i] = GantryStateMapper.get(asmGantryState[i]);
+         }
+         return itacGantryState;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static GantryState[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.GantryState[] asmGantryState)
+      {
+         if (asmGantryState == null) { return null; }
+         GantryState[] itacGantryState = new GantryState[asmGantryState.Length];
+         for (int i = 0; i < asmGantryState.Length; i++)
+         {
+            itacGantryState[i] = GantryStateMapper.get(asmGantryState[i]);
+         }
+         return itacGantryState;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/HeadMapper.cs

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class HeadMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head get(Head itacHead)
+         {
+            if (itacHead == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head asmHead = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head();
+            mapItac2Asm(asmHead, itacHead);
+            return asmHead;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head asmHead, Head itacHead)
+      {
+         asmHead.HeadNumber = itacHead.HeadNumber;
+         asmHead.GantryNumber = itacHead.GantryNumber;
+         asmHead.HeadType = itacHead.HeadType;
+         asmHead.Bypassed = itacHead.Bypassed;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head[] get(Head[] itacHead)
+      {
+         if (itacHead == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head[] asmHead = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head[itacHead.Length];
+         for (int i = 0; i < itacHead.Length; i++)
+         {
+            // to itac array
+            asmHead[i] = HeadMapper.get(itacHead[i]);
+         }
+         return asmHead;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head> getList(Head[] asmHead)
+      {
+         if (asmHead == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head> itacHead = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head>();
+         for (int i = 0; i < asmHead.Length; i++)
+         {
+            itacHead.Add(HeadMapper.get(asmHead[i]));
+         }
+         return itacHead;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static Head get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head asmHead)
+      {
+         if (asmHead == null) { return null; }
+         Head itacHead = new Head();
+         mapAsm2Itac(asmHead, itacHead);
+         return itacHead;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head asmHead, Head itacHead)
+      {
+         itacHead.HeadNumber = asmHead.HeadNumber;
+         itacHead.GantryNumber = asmHead.GantryNumber;
+         itacHead.HeadType = asmHead.HeadType;
+         itacHead.Bypassed = asmHead.Bypassed;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static Head[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head> asmHead)
+      {
+         if (asmHead == null) { return null; }
+         Head[] itacHead = new Head[asmHead.Count];
+         for (int i = 0; i < asmHead.Count; i++)
+         {
+            itacHead[i] = HeadMapper.get(asmHead[i]);
+         }
+         return itacHead;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static Head[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Head[] asmHead)
+      {
+         if (asmHead == null) { return null; }
+         Head[] itacHead = new Head[asmHead.Length];
+         for (int i = 0; i < asmHead.Length; i++)
+         {
+            itacHead[i] = HeadMapper.get(asmHead[i]);
+         }
+         return itacHead;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/LineBaseMapper.cs

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class LineBaseMapper:MonitoringDataMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+       /*  public static Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase get(LineBase itacLineBase)
+         {
+            if (itacLineBase == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase asmLineBase = new Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase(Asm.As.Oib.SiplacePro.Proxy.Business.Types.ResourceIDs.AttachableheadtypeCp_20);
+            mapItac2Asm(asmLineBase, itacLineBase);
+            return asmLineBase;
+         }*/
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase asmLineBase, LineBase itacLineBase)
+      {
+         asmLineBase.FullPath = itacLineBase.FullPath;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase[] get(LineBase[] itacLineBase)
+      {
+         if (itacLineBase == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase[] asmLineBase = new Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase[itacLineBase.Length];
+         for (int i = 0; i < itacLineBase.Length; i++)
+         {
+            // to itac array
+  //          asmLineBase[i] = LineBaseMapper.get(itacLineBase[i]);
+         }
+         return asmLineBase;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase> getList(LineBase[] asmLineBase)
+      {
+         if (asmLineBase == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase> itacLineBase = new List<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase>();
+         for (int i = 0; i < asmLineBase.Length; i++)
+         {
+    //        itacLineBase.Add(LineBaseMapper.get(asmLineBase[i]));
+         }
+         return itacLineBase;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static LineBase get(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase asmLineBase)
+      {
+         if (asmLineBase == null) { return null; }
+         LineBase itacLineBase = new LineBase();
+         mapAsm2Itac(asmLineBase, itacLineBase);
+         return itacLineBase;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase asmLineBase, LineBase itacLineBase)
+      {
+         MonitoringDataMapper.mapAsm2Itac(asmLineBase, itacLineBase);
+         itacLineBase.FullPath = asmLineBase.FullPath;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static LineBase[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase> asmLineBase)
+      {
+         if (asmLineBase == null) { return null; }
+         LineBase[] itacLineBase = new LineBase[asmLineBase.Count];
+         for (int i = 0; i < asmLineBase.Count; i++)
+         {
+            itacLineBase[i] = LineBaseMapper.get(asmLineBase[i]);
+         }
+         return itacLineBase;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static LineBase[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.LineBase[] asmLineBase)
+      {
+         if (asmLineBase == null) { return null; }
+         LineBase[] itacLineBase = new LineBase[asmLineBase.Length];
+         for (int i = 0; i < asmLineBase.Length; i++)
+         {
+            itacLineBase[i] = LineBaseMapper.get(asmLineBase[i]);
+         }
+         return itacLineBase;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/LineMapper.cs

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class LineMapper:LineBaseMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line get(Line itacLine)
+         {
+            if (itacLine == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line asmLine = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line();
+            mapItac2Asm(asmLine, itacLine);
+            return asmLine;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line asmLine, Line itacLine)
+      {
+         asmLine.Name = itacLine.Name;
+         // skip readonly property Stations
+         asmLine.FullPath = itacLine.FullPath;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line[] get(Line[] itacLine)
+      {
+         if (itacLine == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line[] asmLine = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line[itacLine.Length];
+         for (int i = 0; i < itacLine.Length; i++)
+         {
+            // to itac array
+            asmLine[i] = LineMapper.get(itacLine[i]);
+         }
+         return asmLine;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line> getList(Line[] asmLine)
+      {
+         if (asmLine == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line> itacLine = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line>();
+         for (int i = 0; i < asmLine.Length; i++)
+         {
+            itacLine.Add(LineMapper.get(asmLine[i]));
+         }
+         return itacLine;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static Line get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line asmLine)
+      {
+         if (asmLine == null) { return null; }
+         Line itacLine = new Line();
+         mapAsm2Itac(asmLine, itacLine);
+         return itacLine;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line asmLine, Line itacLine)
+      {
+         LineBaseMapper.mapAsm2Itac(asmLine, itacLine);
+         itacLine.Name = asmLine.Name;
+         // maps ASM list 2 iTAC array
+         itacLine.Stations = StationMapper.getArray(asmLine.Stations);
+         itacLine.FullPath = asmLine.FullPath;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static Line[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line> asmLine)
+      {
+         if (asmLine == null) { return null; }
+         Line[] itacLine = new Line[asmLine.Count];
+         for (int i = 0; i < asmLine.Count; i++)
+         {
+            itacLine[i] = LineMapper.get(asmLine[i]);
+         }
+         return itacLine;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static Line[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Line[] asmLine)
+      {
+         if (asmLine == null) { return null; }
+         Line[] itacLine = new Line[asmLine.Length];
+         for (int i = 0; i < asmLine.Length; i++)
+         {
+            itacLine[i] = LineMapper.get(asmLine[i]);
+         }
+         return itacLine;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/MonitoringBaseMapper.cs

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+// this type should be skipped, check class BaseMapper, dictionary ignoreTypeNames

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/MonitoringDataMapper.cs

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class MonitoringDataMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+   /*      public static Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData get(MonitoringData itacMonitoringData)
+         {
+            if (itacMonitoringData == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData asmMonitoringData = new Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData(Asm.As.Oib.SiplacePro.Proxy.Business.Types.ResourceIDs.AttachableheadtypeCp_20);
+            mapItac2Asm(asmMonitoringData, itacMonitoringData);
+            return asmMonitoringData;
+         }*/
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData asmMonitoringData, MonitoringData itacMonitoringData)
+      {
+         asmMonitoringData.FactoryLayoutPath = itacMonitoringData.FactoryLayoutPath;
+         // skip readonly property MessageSendTime
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData[] get(MonitoringData[] itacMonitoringData)
+      {
+         if (itacMonitoringData == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData[] asmMonitoringData = new Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData[itacMonitoringData.Length];
+         for (int i = 0; i < itacMonitoringData.Length; i++)
+         {
+            // to itac array
+   //         asmMonitoringData[i] = MonitoringDataMapper.get(itacMonitoringData[i]);
+         }
+         return asmMonitoringData;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData> getList(MonitoringData[] asmMonitoringData)
+      {
+         if (asmMonitoringData == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData> itacMonitoringData = new List<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData>();
+         for (int i = 0; i < asmMonitoringData.Length; i++)
+         {
+//            itacMonitoringData.Add(MonitoringDataMapper.get(asmMonitoringData[i]));
+         }
+         return itacMonitoringData;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static MonitoringData get(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData asmMonitoringData)
+      {
+         if (asmMonitoringData == null) { return null; }
+         MonitoringData itacMonitoringData = new MonitoringData();
+         mapAsm2Itac(asmMonitoringData, itacMonitoringData);
+         return itacMonitoringData;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData asmMonitoringData, MonitoringData itacMonitoringData)
+      {
+         itacMonitoringData.FactoryLayoutPath = asmMonitoringData.FactoryLayoutPath;
+         itacMonitoringData.MessageSendTime = asmMonitoringData.MessageSendTime;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static MonitoringData[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData> asmMonitoringData)
+      {
+         if (asmMonitoringData == null) { return null; }
+         MonitoringData[] itacMonitoringData = new MonitoringData[asmMonitoringData.Count];
+         for (int i = 0; i < asmMonitoringData.Count; i++)
+         {
+            itacMonitoringData[i] = MonitoringDataMapper.get(asmMonitoringData[i]);
+         }
+         return itacMonitoringData;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static MonitoringData[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.MonitoringData[] asmMonitoringData)
+      {
+         if (asmMonitoringData == null) { return null; }
+         MonitoringData[] itacMonitoringData = new MonitoringData[asmMonitoringData.Length];
+         for (int i = 0; i < asmMonitoringData.Length; i++)
+         {
+            itacMonitoringData[i] = MonitoringDataMapper.get(asmMonitoringData[i]);
+         }
+         return itacMonitoringData;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/PassmodeCollectionMapper.cs

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class PassmodeCollectionMapper:MonitoringDataMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection get(PassmodeCollection itacPassmodeCollection)
+         {
+            if (itacPassmodeCollection == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection asmPassmodeCollection = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection();
+            mapItac2Asm(asmPassmodeCollection, itacPassmodeCollection);
+            return asmPassmodeCollection;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection asmPassmodeCollection, PassmodeCollection itacPassmodeCollection)
+      {
+         // skip readonly property PassmodeStates
+         // skip readonly property Station
+         asmPassmodeCollection.StationTime = itacPassmodeCollection.StationTime;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection[] get(PassmodeCollection[] itacPassmodeCollection)
+      {
+         if (itacPassmodeCollection == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection[] asmPassmodeCollection = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection[itacPassmodeCollection.Length];
+         for (int i = 0; i < itacPassmodeCollection.Length; i++)
+         {
+            // to itac array
+            asmPassmodeCollection[i] = PassmodeCollectionMapper.get(itacPassmodeCollection[i]);
+         }
+         return asmPassmodeCollection;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection> getList(PassmodeCollection[] asmPassmodeCollection)
+      {
+         if (asmPassmodeCollection == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection> itacPassmodeCollection = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection>();
+         for (int i = 0; i < asmPassmodeCollection.Length; i++)
+         {
+            itacPassmodeCollection.Add(PassmodeCollectionMapper.get(asmPassmodeCollection[i]));
+         }
+         return itacPassmodeCollection;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static PassmodeCollection get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection asmPassmodeCollection)
+      {
+         if (asmPassmodeCollection == null) { return null; }
+         PassmodeCollection itacPassmodeCollection = new PassmodeCollection();
+         mapAsm2Itac(asmPassmodeCollection, itacPassmodeCollection);
+         return itacPassmodeCollection;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection asmPassmodeCollection, PassmodeCollection itacPassmodeCollection)
+      {
+         MonitoringDataMapper.mapAsm2Itac(asmPassmodeCollection, itacPassmodeCollection);
+         // maps ASM list 2 iTAC array
+         itacPassmodeCollection.PassmodeStates = PassmodeLocationMapper.getArray(asmPassmodeCollection.PassmodeStates);
+         itacPassmodeCollection.Station = com.itac.oib.monitoring.contracts.data.StationMapper.get(asmPassmodeCollection.Station);
+         // complex asm property Station
+         itacPassmodeCollection.StationTime = asmPassmodeCollection.StationTime;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static PassmodeCollection[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection> asmPassmodeCollection)
+      {
+         if (asmPassmodeCollection == null) { return null; }
+         PassmodeCollection[] itacPassmodeCollection = new PassmodeCollection[asmPassmodeCollection.Count];
+         for (int i = 0; i < asmPassmodeCollection.Count; i++)
+         {
+            itacPassmodeCollection[i] = PassmodeCollectionMapper.get(asmPassmodeCollection[i]);
+         }
+         return itacPassmodeCollection;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static PassmodeCollection[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeCollection[] asmPassmodeCollection)
+      {
+         if (asmPassmodeCollection == null) { return null; }
+         PassmodeCollection[] itacPassmodeCollection = new PassmodeCollection[asmPassmodeCollection.Length];
+         for (int i = 0; i < asmPassmodeCollection.Length; i++)
+         {
+            itacPassmodeCollection[i] = PassmodeCollectionMapper.get(asmPassmodeCollection[i]);
+         }
+         return itacPassmodeCollection;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/PassmodeLocationMapper.cs

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class PassmodeLocationMapper:ProcessingLocationAddressMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation get(PassmodeLocation itacPassmodeLocation)
+         {
+            if (itacPassmodeLocation == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation asmPassmodeLocation = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation();
+            mapItac2Asm(asmPassmodeLocation, itacPassmodeLocation);
+            return asmPassmodeLocation;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation asmPassmodeLocation, PassmodeLocation itacPassmodeLocation)
+      {
+         // skip readonly property PassmodeStatusType
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation[] get(PassmodeLocation[] itacPassmodeLocation)
+      {
+         if (itacPassmodeLocation == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation[] asmPassmodeLocation = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation[itacPassmodeLocation.Length];
+         for (int i = 0; i < itacPassmodeLocation.Length; i++)
+         {
+            // to itac array
+            asmPassmodeLocation[i] = PassmodeLocationMapper.get(itacPassmodeLocation[i]);
+         }
+         return asmPassmodeLocation;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation> getList(PassmodeLocation[] asmPassmodeLocation)
+      {
+         if (asmPassmodeLocation == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation> itacPassmodeLocation = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation>();
+         for (int i = 0; i < asmPassmodeLocation.Length; i++)
+         {
+            itacPassmodeLocation.Add(PassmodeLocationMapper.get(asmPassmodeLocation[i]));
+         }
+         return itacPassmodeLocation;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static PassmodeLocation get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation asmPassmodeLocation)
+      {
+         if (asmPassmodeLocation == null) { return null; }
+         PassmodeLocation itacPassmodeLocation = new PassmodeLocation();
+         mapAsm2Itac(asmPassmodeLocation, itacPassmodeLocation);
+         return itacPassmodeLocation;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation asmPassmodeLocation, PassmodeLocation itacPassmodeLocation)
+      {
+         ProcessingLocationAddressMapper.mapAsm2Itac(asmPassmodeLocation, itacPassmodeLocation);
+         itacPassmodeLocation.PassmodeStatusType = com.itac.oib.monitoring.contracts.data.PassmodeStatusTypeMapper.get(asmPassmodeLocation.PassmodeStatusType);
+         // complex asm property PassmodeStatusType
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static PassmodeLocation[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation> asmPassmodeLocation)
+      {
+         if (asmPassmodeLocation == null) { return null; }
+         PassmodeLocation[] itacPassmodeLocation = new PassmodeLocation[asmPassmodeLocation.Count];
+         for (int i = 0; i < asmPassmodeLocation.Count; i++)
+         {
+            itacPassmodeLocation[i] = PassmodeLocationMapper.get(asmPassmodeLocation[i]);
+         }
+         return itacPassmodeLocation;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static PassmodeLocation[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PassmodeLocation[] asmPassmodeLocation)
+      {
+         if (asmPassmodeLocation == null) { return null; }
+         PassmodeLocation[] itacPassmodeLocation = new PassmodeLocation[asmPassmodeLocation.Length];
+         for (int i = 0; i < asmPassmodeLocation.Length; i++)
+         {
+            itacPassmodeLocation[i] = PassmodeLocationMapper.get(asmPassmodeLocation[i]);
+         }
+         return itacPassmodeLocation;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/PassmodeStatusTypeMapper.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:59
+using System;
+using System.Collections.Generic;
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class PassmodeStatusTypeMapper
+   {
+
+      // map asm enum value to itac enum value
+      public static PassmodeStatusType get(Asm.As.Oib.Monitoring.Proxy.Business.Types.PassmodeStatusType passmodeStatusType)
+      {
+         int intValue = (int)passmodeStatusType;
+         return (PassmodeStatusType)intValue;
+      }
+
+      // map itac enum value to ASM enum value
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Types.PassmodeStatusType get(PassmodeStatusType passmodeStatusType)
+      {
+         int intValue = (int)passmodeStatusType;
+         return (Asm.As.Oib.Monitoring.Proxy.Business.Types.PassmodeStatusType)intValue;
+      }
+   }
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/PickupErrorMapper.cs

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class PickupErrorMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError get(PickupError itacPickupError)
+         {
+            if (itacPickupError == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError asmPickupError = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError();
+            mapItac2Asm(asmPickupError, itacPickupError);
+            return asmPickupError;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError asmPickupError, PickupError itacPickupError)
+      {
+         asmPickupError.StationTime = itacPickupError.StationTime;
+         asmPickupError.Head = itacPickupError.Head;
+         asmPickupError.Segment = itacPickupError.Segment;
+         asmPickupError.Nozzle = itacPickupError.Nozzle;
+         asmPickupError.ErrorType = itacPickupError.ErrorType;
+         // skip readonly property ErrorDescription
+         asmPickupError.Gantry = itacPickupError.Gantry;
+         asmPickupError.FeederId = itacPickupError.FeederId;
+         // complex property TrackEntry, isArray:False, isGeneric:False
+         asmPickupError.TrackEntry = com.itac.oib.monitoring.contracts.data.TrackEntryMapper.get( itacPickupError.TrackEntry);
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError[] get(PickupError[] itacPickupError)
+      {
+         if (itacPickupError == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError[] asmPickupError = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError[itacPickupError.Length];
+         for (int i = 0; i < itacPickupError.Length; i++)
+         {
+            // to itac array
+            asmPickupError[i] = PickupErrorMapper.get(itacPickupError[i]);
+         }
+         return asmPickupError;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError> getList(PickupError[] asmPickupError)
+      {
+         if (asmPickupError == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError> itacPickupError = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError>();
+         for (int i = 0; i < asmPickupError.Length; i++)
+         {
+            itacPickupError.Add(PickupErrorMapper.get(asmPickupError[i]));
+         }
+         return itacPickupError;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static PickupError get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError asmPickupError)
+      {
+         if (asmPickupError == null) { return null; }
+         PickupError itacPickupError = new PickupError();
+         mapAsm2Itac(asmPickupError, itacPickupError);
+         return itacPickupError;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError asmPickupError, PickupError itacPickupError)
+      {
+         itacPickupError.StationTime = asmPickupError.StationTime;
+         itacPickupError.Head = asmPickupError.Head;
+         itacPickupError.Segment = asmPickupError.Segment;
+         itacPickupError.Nozzle = asmPickupError.Nozzle;
+         itacPickupError.ErrorType = asmPickupError.ErrorType;
+         itacPickupError.ErrorDescription = asmPickupError.ErrorDescription;
+         itacPickupError.Gantry = asmPickupError.Gantry;
+         itacPickupError.FeederId = asmPickupError.FeederId;
+         itacPickupError.TrackEntry = com.itac.oib.monitoring.contracts.data.TrackEntryMapper.get(asmPickupError.TrackEntry);
+         // complex asm property TrackEntry
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static PickupError[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError> asmPickupError)
+      {
+         if (asmPickupError == null) { return null; }
+         PickupError[] itacPickupError = new PickupError[asmPickupError.Count];
+         for (int i = 0; i < asmPickupError.Count; i++)
+         {
+            itacPickupError[i] = PickupErrorMapper.get(asmPickupError[i]);
+         }
+         return itacPickupError;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static PickupError[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupError[] asmPickupError)
+      {
+         if (asmPickupError == null) { return null; }
+         PickupError[] itacPickupError = new PickupError[asmPickupError.Length];
+         for (int i = 0; i < asmPickupError.Length; i++)
+         {
+            itacPickupError[i] = PickupErrorMapper.get(asmPickupError[i]);
+         }
+         return itacPickupError;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/PickupObservationDataMapper.cs

@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+// skip property Guid, declared in PickupObservationData
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class PickupObservationDataMapper:MonitoringDataMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData get(PickupObservationData itacPickupObservationData)
+         {
+            if (itacPickupObservationData == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData asmPickupObservationData = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData();
+            mapItac2Asm(asmPickupObservationData, itacPickupObservationData);
+            return asmPickupObservationData;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData asmPickupObservationData, PickupObservationData itacPickupObservationData)
+      {
+         // skip property Guid, declared in PickupObservationData
+         asmPickupObservationData.PeriodStart = itacPickupObservationData.PeriodStart;
+         asmPickupObservationData.PeriodEnd = itacPickupObservationData.PeriodEnd;
+         // skip readonly property UsedDetails
+         // skip readonly property PickupErrors
+         // skip readonly property Station
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData[] get(PickupObservationData[] itacPickupObservationData)
+      {
+         if (itacPickupObservationData == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData[] asmPickupObservationData = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData[itacPickupObservationData.Length];
+         for (int i = 0; i < itacPickupObservationData.Length; i++)
+         {
+            // to itac array
+            asmPickupObservationData[i] = PickupObservationDataMapper.get(itacPickupObservationData[i]);
+         }
+         return asmPickupObservationData;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData> getList(PickupObservationData[] asmPickupObservationData)
+      {
+         if (asmPickupObservationData == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData> itacPickupObservationData = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData>();
+         for (int i = 0; i < asmPickupObservationData.Length; i++)
+         {
+            itacPickupObservationData.Add(PickupObservationDataMapper.get(asmPickupObservationData[i]));
+         }
+         return itacPickupObservationData;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static PickupObservationData get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData asmPickupObservationData)
+      {
+         if (asmPickupObservationData == null) { return null; }
+         PickupObservationData itacPickupObservationData = new PickupObservationData();
+         mapAsm2Itac(asmPickupObservationData, itacPickupObservationData);
+         return itacPickupObservationData;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData asmPickupObservationData, PickupObservationData itacPickupObservationData)
+      {
+         MonitoringDataMapper.mapAsm2Itac(asmPickupObservationData, itacPickupObservationData);
+         // skip property Guid, declared in PickupObservationData
+         itacPickupObservationData.PeriodStart = asmPickupObservationData.PeriodStart;
+         itacPickupObservationData.PeriodEnd = asmPickupObservationData.PeriodEnd;
+         // maps ASM list 2 iTAC array
+         itacPickupObservationData.UsedDetails = UsedDetailMapper.getArray(asmPickupObservationData.UsedDetails);
+         // maps ASM list 2 iTAC array
+         itacPickupObservationData.PickupErrors = PickupErrorMapper.getArray(asmPickupObservationData.PickupErrors);
+         itacPickupObservationData.Station = com.itac.oib.monitoring.contracts.data.StationMapper.get(asmPickupObservationData.Station);
+         // complex asm property Station
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static PickupObservationData[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData> asmPickupObservationData)
+      {
+         if (asmPickupObservationData == null) { return null; }
+         PickupObservationData[] itacPickupObservationData = new PickupObservationData[asmPickupObservationData.Count];
+         for (int i = 0; i < asmPickupObservationData.Count; i++)
+         {
+            itacPickupObservationData[i] = PickupObservationDataMapper.get(asmPickupObservationData[i]);
+         }
+         return itacPickupObservationData;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static PickupObservationData[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.PickupObservationData[] asmPickupObservationData)
+      {
+         if (asmPickupObservationData == null) { return null; }
+         PickupObservationData[] itacPickupObservationData = new PickupObservationData[asmPickupObservationData.Length];
+         for (int i = 0; i < asmPickupObservationData.Length; i++)
+         {
+            itacPickupObservationData[i] = PickupObservationDataMapper.get(asmPickupObservationData[i]);
+         }
+         return itacPickupObservationData;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/ProcessedBoardMapper.cs

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class ProcessedBoardMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard get(ProcessedBoard itacProcessedBoard)
+         {
+            if (itacProcessedBoard == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard asmProcessedBoard = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard();
+            mapItac2Asm(asmProcessedBoard, itacProcessedBoard);
+            return asmProcessedBoard;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard asmProcessedBoard, ProcessedBoard itacProcessedBoard)
+      {
+         asmProcessedBoard.StationTime = itacProcessedBoard.StationTime;
+         asmProcessedBoard.BoardName = itacProcessedBoard.BoardName;
+         asmProcessedBoard.BoardNumber = itacProcessedBoard.BoardNumber;
+         // complex property Conveyor, isArray:False, isGeneric:False
+         asmProcessedBoard.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get( itacProcessedBoard.Conveyor);
+         asmProcessedBoard.Barcode = itacProcessedBoard.Barcode;
+         // complex property Status, isArray:False, isGeneric:False
+         asmProcessedBoard.Status = com.itac.oib.monitoring.contracts.data.BoardStatusTypeMapper.get( itacProcessedBoard.Status);
+         asmProcessedBoard.PanelCount = itacProcessedBoard.PanelCount;
+         // complex property SubConveyor, isArray:False, isGeneric:False
+         asmProcessedBoard.SubConveyor = com.itac.oib.monitoring.contracts.data.SubConveyorTypeMapper.get( itacProcessedBoard.SubConveyor);
+         asmProcessedBoard.BoardSide = itacProcessedBoard.BoardSide;
+         asmProcessedBoard.BoardFullPath = itacProcessedBoard.BoardFullPath;
+         asmProcessedBoard.BuildTimePa1 = itacProcessedBoard.BuildTimePa1;
+         asmProcessedBoard.BuildTimePa2 = itacProcessedBoard.BuildTimePa2;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard[] get(ProcessedBoard[] itacProcessedBoard)
+      {
+         if (itacProcessedBoard == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard[] asmProcessedBoard = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard[itacProcessedBoard.Length];
+         for (int i = 0; i < itacProcessedBoard.Length; i++)
+         {
+            // to itac array
+            asmProcessedBoard[i] = ProcessedBoardMapper.get(itacProcessedBoard[i]);
+         }
+         return asmProcessedBoard;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard> getList(ProcessedBoard[] asmProcessedBoard)
+      {
+         if (asmProcessedBoard == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard> itacProcessedBoard = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard>();
+         for (int i = 0; i < asmProcessedBoard.Length; i++)
+         {
+            itacProcessedBoard.Add(ProcessedBoardMapper.get(asmProcessedBoard[i]));
+         }
+         return itacProcessedBoard;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static ProcessedBoard get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard asmProcessedBoard)
+      {
+         if (asmProcessedBoard == null) { return null; }
+         ProcessedBoard itacProcessedBoard = new ProcessedBoard();
+         mapAsm2Itac(asmProcessedBoard, itacProcessedBoard);
+         return itacProcessedBoard;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard asmProcessedBoard, ProcessedBoard itacProcessedBoard)
+      {
+         itacProcessedBoard.StationTime = asmProcessedBoard.StationTime;
+         itacProcessedBoard.BoardName = asmProcessedBoard.BoardName;
+         itacProcessedBoard.BoardNumber = asmProcessedBoard.BoardNumber;
+         itacProcessedBoard.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get(asmProcessedBoard.Conveyor);
+         // complex asm property Conveyor
+         itacProcessedBoard.Barcode = asmProcessedBoard.Barcode;
+         itacProcessedBoard.Status = com.itac.oib.monitoring.contracts.data.BoardStatusTypeMapper.get(asmProcessedBoard.Status);
+         // complex asm property Status
+         itacProcessedBoard.PanelCount = asmProcessedBoard.PanelCount;
+         itacProcessedBoard.SubConveyor = com.itac.oib.monitoring.contracts.data.SubConveyorTypeMapper.get(asmProcessedBoard.SubConveyor);
+         // complex asm property SubConveyor
+         itacProcessedBoard.BoardSide = asmProcessedBoard.BoardSide;
+         itacProcessedBoard.BoardFullPath = asmProcessedBoard.BoardFullPath;
+         itacProcessedBoard.BuildTimePa1 = asmProcessedBoard.BuildTimePa1;
+         itacProcessedBoard.BuildTimePa2 = asmProcessedBoard.BuildTimePa2;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static ProcessedBoard[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard> asmProcessedBoard)
+      {
+         if (asmProcessedBoard == null) { return null; }
+         ProcessedBoard[] itacProcessedBoard = new ProcessedBoard[asmProcessedBoard.Count];
+         for (int i = 0; i < asmProcessedBoard.Count; i++)
+         {
+            itacProcessedBoard[i] = ProcessedBoardMapper.get(asmProcessedBoard[i]);
+         }
+         return itacProcessedBoard;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static ProcessedBoard[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessedBoard[] asmProcessedBoard)
+      {
+         if (asmProcessedBoard == null) { return null; }
+         ProcessedBoard[] itacProcessedBoard = new ProcessedBoard[asmProcessedBoard.Length];
+         for (int i = 0; i < asmProcessedBoard.Length; i++)
+         {
+            itacProcessedBoard[i] = ProcessedBoardMapper.get(asmProcessedBoard[i]);
+         }
+         return itacProcessedBoard;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/ProcessingLocationAddressMapper.cs

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class ProcessingLocationAddressMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress get(ProcessingLocationAddress itacProcessingLocationAddress)
+         {
+            if (itacProcessingLocationAddress == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress asmProcessingLocationAddress = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress();
+            mapItac2Asm(asmProcessingLocationAddress, itacProcessingLocationAddress);
+            return asmProcessingLocationAddress;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress asmProcessingLocationAddress, ProcessingLocationAddress itacProcessingLocationAddress)
+      {
+         // complex property Conveyor, isArray:False, isGeneric:False
+         asmProcessingLocationAddress.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get( itacProcessingLocationAddress.Conveyor);
+         // complex property SubConveyor, isArray:False, isGeneric:False
+         asmProcessingLocationAddress.SubConveyor = com.itac.oib.monitoring.contracts.data.SubConveyorTypeMapper.get( itacProcessingLocationAddress.SubConveyor);
+         asmProcessingLocationAddress.ProcessingArea = itacProcessingLocationAddress.ProcessingArea;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress[] get(ProcessingLocationAddress[] itacProcessingLocationAddress)
+      {
+         if (itacProcessingLocationAddress == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress[] asmProcessingLocationAddress = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress[itacProcessingLocationAddress.Length];
+         for (int i = 0; i < itacProcessingLocationAddress.Length; i++)
+         {
+            // to itac array
+            asmProcessingLocationAddress[i] = ProcessingLocationAddressMapper.get(itacProcessingLocationAddress[i]);
+         }
+         return asmProcessingLocationAddress;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress> getList(ProcessingLocationAddress[] asmProcessingLocationAddress)
+      {
+         if (asmProcessingLocationAddress == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress> itacProcessingLocationAddress = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress>();
+         for (int i = 0; i < asmProcessingLocationAddress.Length; i++)
+         {
+            itacProcessingLocationAddress.Add(ProcessingLocationAddressMapper.get(asmProcessingLocationAddress[i]));
+         }
+         return itacProcessingLocationAddress;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static ProcessingLocationAddress get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress asmProcessingLocationAddress)
+      {
+         if (asmProcessingLocationAddress == null) { return null; }
+         ProcessingLocationAddress itacProcessingLocationAddress = new ProcessingLocationAddress();
+         mapAsm2Itac(asmProcessingLocationAddress, itacProcessingLocationAddress);
+         return itacProcessingLocationAddress;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress asmProcessingLocationAddress, ProcessingLocationAddress itacProcessingLocationAddress)
+      {
+         itacProcessingLocationAddress.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get(asmProcessingLocationAddress.Conveyor);
+         // complex asm property Conveyor
+         itacProcessingLocationAddress.SubConveyor = com.itac.oib.monitoring.contracts.data.SubConveyorTypeMapper.get(asmProcessingLocationAddress.SubConveyor);
+         // complex asm property SubConveyor
+         itacProcessingLocationAddress.ProcessingArea = asmProcessingLocationAddress.ProcessingArea;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static ProcessingLocationAddress[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress> asmProcessingLocationAddress)
+      {
+         if (asmProcessingLocationAddress == null) { return null; }
+         ProcessingLocationAddress[] itacProcessingLocationAddress = new ProcessingLocationAddress[asmProcessingLocationAddress.Count];
+         for (int i = 0; i < asmProcessingLocationAddress.Count; i++)
+         {
+            itacProcessingLocationAddress[i] = ProcessingLocationAddressMapper.get(asmProcessingLocationAddress[i]);
+         }
+         return itacProcessingLocationAddress;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static ProcessingLocationAddress[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationAddress[] asmProcessingLocationAddress)
+      {
+         if (asmProcessingLocationAddress == null) { return null; }
+         ProcessingLocationAddress[] itacProcessingLocationAddress = new ProcessingLocationAddress[asmProcessingLocationAddress.Length];
+         for (int i = 0; i < asmProcessingLocationAddress.Length; i++)
+         {
+            itacProcessingLocationAddress[i] = ProcessingLocationAddressMapper.get(asmProcessingLocationAddress[i]);
+         }
+         return itacProcessingLocationAddress;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/ProcessingLocationStateMapper.cs

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class ProcessingLocationStateMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState get(ProcessingLocationState itacProcessingLocationState)
+         {
+            if (itacProcessingLocationState == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState asmProcessingLocationState = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState();
+            mapItac2Asm(asmProcessingLocationState, itacProcessingLocationState);
+            return asmProcessingLocationState;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState asmProcessingLocationState, ProcessingLocationState itacProcessingLocationState)
+      {
+         // complex property Conveyor, isArray:False, isGeneric:False
+         asmProcessingLocationState.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get( itacProcessingLocationState.Conveyor);
+         asmProcessingLocationState.ProcessingArea = itacProcessingLocationState.ProcessingArea;
+         // complex property State, isArray:False, isGeneric:False
+         asmProcessingLocationState.State = com.itac.oib.monitoring.contracts.data.StationStateTypeMapper.get( itacProcessingLocationState.State);
+         asmProcessingLocationState.SequenceNumber = itacProcessingLocationState.SequenceNumber;
+         asmProcessingLocationState.StationTime = itacProcessingLocationState.StationTime;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState[] get(ProcessingLocationState[] itacProcessingLocationState)
+      {
+         if (itacProcessingLocationState == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState[] asmProcessingLocationState = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState[itacProcessingLocationState.Length];
+         for (int i = 0; i < itacProcessingLocationState.Length; i++)
+         {
+            // to itac array
+            asmProcessingLocationState[i] = ProcessingLocationStateMapper.get(itacProcessingLocationState[i]);
+         }
+         return asmProcessingLocationState;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState> getList(ProcessingLocationState[] asmProcessingLocationState)
+      {
+         if (asmProcessingLocationState == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState> itacProcessingLocationState = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState>();
+         for (int i = 0; i < asmProcessingLocationState.Length; i++)
+         {
+            itacProcessingLocationState.Add(ProcessingLocationStateMapper.get(asmProcessingLocationState[i]));
+         }
+         return itacProcessingLocationState;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static ProcessingLocationState get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState asmProcessingLocationState)
+      {
+         if (asmProcessingLocationState == null) { return null; }
+         ProcessingLocationState itacProcessingLocationState = new ProcessingLocationState();
+         mapAsm2Itac(asmProcessingLocationState, itacProcessingLocationState);
+         return itacProcessingLocationState;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState asmProcessingLocationState, ProcessingLocationState itacProcessingLocationState)
+      {
+         itacProcessingLocationState.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get(asmProcessingLocationState.Conveyor);
+         // complex asm property Conveyor
+         itacProcessingLocationState.ProcessingArea = asmProcessingLocationState.ProcessingArea;
+         itacProcessingLocationState.State = com.itac.oib.monitoring.contracts.data.StationStateTypeMapper.get(asmProcessingLocationState.State);
+         // complex asm property State
+         itacProcessingLocationState.SequenceNumber = asmProcessingLocationState.SequenceNumber;
+         itacProcessingLocationState.StationTime = asmProcessingLocationState.StationTime;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static ProcessingLocationState[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState> asmProcessingLocationState)
+      {
+         if (asmProcessingLocationState == null) { return null; }
+         ProcessingLocationState[] itacProcessingLocationState = new ProcessingLocationState[asmProcessingLocationState.Count];
+         for (int i = 0; i < asmProcessingLocationState.Count; i++)
+         {
+            itacProcessingLocationState[i] = ProcessingLocationStateMapper.get(asmProcessingLocationState[i]);
+         }
+         return itacProcessingLocationState;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static ProcessingLocationState[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.ProcessingLocationState[] asmProcessingLocationState)
+      {
+         if (asmProcessingLocationState == null) { return null; }
+         ProcessingLocationState[] itacProcessingLocationState = new ProcessingLocationState[asmProcessingLocationState.Length];
+         for (int i = 0; i < asmProcessingLocationState.Length; i++)
+         {
+            itacProcessingLocationState[i] = ProcessingLocationStateMapper.get(asmProcessingLocationState[i]);
+         }
+         return itacProcessingLocationState;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/ProcessingModeTypeMapper.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:59
+using System;
+using System.Collections.Generic;
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class ProcessingModeTypeMapper
+   {
+
+      // map asm enum value to itac enum value
+      public static ProcessingModeType get(Asm.As.Oib.Monitoring.Proxy.Business.Types.ProcessingModeType processingModeType)
+      {
+         int intValue = (int)processingModeType;
+         return (ProcessingModeType)intValue;
+      }
+
+      // map itac enum value to ASM enum value
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Types.ProcessingModeType get(ProcessingModeType processingModeType)
+      {
+         int intValue = (int)processingModeType;
+         return (Asm.As.Oib.Monitoring.Proxy.Business.Types.ProcessingModeType)intValue;
+      }
+   }
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/RecipeAddOnMapper.cs

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class RecipeAddOnMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn get(RecipeAddOn itacRecipeAddOn)
+         {
+            if (itacRecipeAddOn == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn asmRecipeAddOn = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn();
+            mapItac2Asm(asmRecipeAddOn, itacRecipeAddOn);
+            return asmRecipeAddOn;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn asmRecipeAddOn, RecipeAddOn itacRecipeAddOn)
+      {
+         asmRecipeAddOn.ProcessingArea = itacRecipeAddOn.ProcessingArea;
+         // complex property PlacementMode, isArray:False, isGeneric:False
+         asmRecipeAddOn.PlacementMode = com.itac.oib.monitoring.contracts.data.ProcessingModeTypeMapper.get( itacRecipeAddOn.PlacementMode);
+         asmRecipeAddOn.BuildTime = itacRecipeAddOn.BuildTime;
+         asmRecipeAddOn.StationTactTime = itacRecipeAddOn.StationTactTime;
+         asmRecipeAddOn.ParallelProcessingFactor = itacRecipeAddOn.ParallelProcessingFactor;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn[] get(RecipeAddOn[] itacRecipeAddOn)
+      {
+         if (itacRecipeAddOn == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn[] asmRecipeAddOn = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn[itacRecipeAddOn.Length];
+         for (int i = 0; i < itacRecipeAddOn.Length; i++)
+         {
+            // to itac array
+            asmRecipeAddOn[i] = RecipeAddOnMapper.get(itacRecipeAddOn[i]);
+         }
+         return asmRecipeAddOn;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn> getList(RecipeAddOn[] asmRecipeAddOn)
+      {
+         if (asmRecipeAddOn == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn> itacRecipeAddOn = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn>();
+         for (int i = 0; i < asmRecipeAddOn.Length; i++)
+         {
+            itacRecipeAddOn.Add(RecipeAddOnMapper.get(asmRecipeAddOn[i]));
+         }
+         return itacRecipeAddOn;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static RecipeAddOn get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn asmRecipeAddOn)
+      {
+         if (asmRecipeAddOn == null) { return null; }
+         RecipeAddOn itacRecipeAddOn = new RecipeAddOn();
+         mapAsm2Itac(asmRecipeAddOn, itacRecipeAddOn);
+         return itacRecipeAddOn;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn asmRecipeAddOn, RecipeAddOn itacRecipeAddOn)
+      {
+         itacRecipeAddOn.ProcessingArea = asmRecipeAddOn.ProcessingArea;
+         itacRecipeAddOn.PlacementMode = com.itac.oib.monitoring.contracts.data.ProcessingModeTypeMapper.get(asmRecipeAddOn.PlacementMode);
+         // complex asm property PlacementMode
+         itacRecipeAddOn.BuildTime = asmRecipeAddOn.BuildTime;
+         itacRecipeAddOn.StationTactTime = asmRecipeAddOn.StationTactTime;
+         itacRecipeAddOn.ParallelProcessingFactor = asmRecipeAddOn.ParallelProcessingFactor;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static RecipeAddOn[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn> asmRecipeAddOn)
+      {
+         if (asmRecipeAddOn == null) { return null; }
+         RecipeAddOn[] itacRecipeAddOn = new RecipeAddOn[asmRecipeAddOn.Count];
+         for (int i = 0; i < asmRecipeAddOn.Count; i++)
+         {
+            itacRecipeAddOn[i] = RecipeAddOnMapper.get(asmRecipeAddOn[i]);
+         }
+         return itacRecipeAddOn;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static RecipeAddOn[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeAddOn[] asmRecipeAddOn)
+      {
+         if (asmRecipeAddOn == null) { return null; }
+         RecipeAddOn[] itacRecipeAddOn = new RecipeAddOn[asmRecipeAddOn.Length];
+         for (int i = 0; i < asmRecipeAddOn.Length; i++)
+         {
+            itacRecipeAddOn[i] = RecipeAddOnMapper.get(asmRecipeAddOn[i]);
+         }
+         return itacRecipeAddOn;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/RecipeBaseMapper.cs

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class RecipeBaseMapper:MonitoringDataMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+   /*      public static Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase get(RecipeBase itacRecipeBase)
+         {
+            if (itacRecipeBase == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase asmRecipeBase = new Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase(Asm.As.Oib.SiplacePro.Proxy.Business.Types.ResourceIDs.AttachableheadtypeCp_20);
+            mapItac2Asm(asmRecipeBase, itacRecipeBase);
+            return asmRecipeBase;
+         }*/
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase asmRecipeBase, RecipeBase itacRecipeBase)
+      {
+         // skip readonly property Station
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase[] get(RecipeBase[] itacRecipeBase)
+      {
+         if (itacRecipeBase == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase[] asmRecipeBase = new Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase[itacRecipeBase.Length];
+         for (int i = 0; i < itacRecipeBase.Length; i++)
+         {
+            // to itac array
+    //        asmRecipeBase[i] = RecipeBaseMapper.get(itacRecipeBase[i]);
+         }
+         return asmRecipeBase;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase> getList(RecipeBase[] asmRecipeBase)
+      {
+         if (asmRecipeBase == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase> itacRecipeBase = new List<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase>();
+         for (int i = 0; i < asmRecipeBase.Length; i++)
+         {
+      //      itacRecipeBase.Add(RecipeBaseMapper.get(asmRecipeBase[i]));
+         }
+         return itacRecipeBase;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static RecipeBase get(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase asmRecipeBase)
+      {
+         if (asmRecipeBase == null) { return null; }
+         RecipeBase itacRecipeBase = new RecipeBase();
+         mapAsm2Itac(asmRecipeBase, itacRecipeBase);
+         return itacRecipeBase;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase asmRecipeBase, RecipeBase itacRecipeBase)
+      {
+         MonitoringDataMapper.mapAsm2Itac(asmRecipeBase, itacRecipeBase);
+         itacRecipeBase.Station = com.itac.oib.monitoring.contracts.data.StationMapper.get(asmRecipeBase.Station);
+         // complex asm property Station
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static RecipeBase[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase> asmRecipeBase)
+      {
+         if (asmRecipeBase == null) { return null; }
+         RecipeBase[] itacRecipeBase = new RecipeBase[asmRecipeBase.Count];
+         for (int i = 0; i < asmRecipeBase.Count; i++)
+         {
+            itacRecipeBase[i] = RecipeBaseMapper.get(asmRecipeBase[i]);
+         }
+         return itacRecipeBase;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static RecipeBase[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.RecipeBase[] asmRecipeBase)
+      {
+         if (asmRecipeBase == null) { return null; }
+         RecipeBase[] itacRecipeBase = new RecipeBase[asmRecipeBase.Length];
+         for (int i = 0; i < asmRecipeBase.Length; i++)
+         {
+            itacRecipeBase[i] = RecipeBaseMapper.get(asmRecipeBase[i]);
+         }
+         return itacRecipeBase;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/RecipeChangeMapper.cs

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class RecipeChangeMapper:RecipeBaseMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange get(RecipeChange itacRecipeChange)
+         {
+            if (itacRecipeChange == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange asmRecipeChange = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange();
+            mapItac2Asm(asmRecipeChange, itacRecipeChange);
+            return asmRecipeChange;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange asmRecipeChange, RecipeChange itacRecipeChange)
+      {
+         // complex property Recipe, isArray:False, isGeneric:False
+         asmRecipeChange.Recipe = com.itac.oib.monitoring.contracts.data.RecipeMapper.get( itacRecipeChange.Recipe);
+         asmRecipeChange.ProcessingArea = itacRecipeChange.ProcessingArea;
+         // complex property Conveyor, isArray:False, isGeneric:False
+         asmRecipeChange.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get( itacRecipeChange.Conveyor);
+         // complex property SubConveyor, isArray:False, isGeneric:False
+         asmRecipeChange.SubConveyor = com.itac.oib.monitoring.contracts.data.SubConveyorTypeMapper.get( itacRecipeChange.SubConveyor);
+         asmRecipeChange.StationTime = itacRecipeChange.StationTime;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange[] get(RecipeChange[] itacRecipeChange)
+      {
+         if (itacRecipeChange == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange[] asmRecipeChange = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange[itacRecipeChange.Length];
+         for (int i = 0; i < itacRecipeChange.Length; i++)
+         {
+            // to itac array
+            asmRecipeChange[i] = RecipeChangeMapper.get(itacRecipeChange[i]);
+         }
+         return asmRecipeChange;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange> getList(RecipeChange[] asmRecipeChange)
+      {
+         if (asmRecipeChange == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange> itacRecipeChange = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange>();
+         for (int i = 0; i < asmRecipeChange.Length; i++)
+         {
+            itacRecipeChange.Add(RecipeChangeMapper.get(asmRecipeChange[i]));
+         }
+         return itacRecipeChange;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static RecipeChange get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange asmRecipeChange)
+      {
+         if (asmRecipeChange == null) { return null; }
+         RecipeChange itacRecipeChange = new RecipeChange();
+         mapAsm2Itac(asmRecipeChange, itacRecipeChange);
+         return itacRecipeChange;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange asmRecipeChange, RecipeChange itacRecipeChange)
+      {
+         RecipeBaseMapper.mapAsm2Itac(asmRecipeChange, itacRecipeChange);
+         itacRecipeChange.Recipe = com.itac.oib.monitoring.contracts.data.RecipeMapper.get(asmRecipeChange.Recipe);
+         // complex asm property Recipe
+         itacRecipeChange.ProcessingArea = asmRecipeChange.ProcessingArea;
+         itacRecipeChange.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get(asmRecipeChange.Conveyor);
+         // complex asm property Conveyor
+         itacRecipeChange.SubConveyor = com.itac.oib.monitoring.contracts.data.SubConveyorTypeMapper.get(asmRecipeChange.SubConveyor);
+         // complex asm property SubConveyor
+         itacRecipeChange.StationTime = asmRecipeChange.StationTime;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static RecipeChange[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange> asmRecipeChange)
+      {
+         if (asmRecipeChange == null) { return null; }
+         RecipeChange[] itacRecipeChange = new RecipeChange[asmRecipeChange.Count];
+         for (int i = 0; i < asmRecipeChange.Count; i++)
+         {
+            itacRecipeChange[i] = RecipeChangeMapper.get(asmRecipeChange[i]);
+         }
+         return itacRecipeChange;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static RecipeChange[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeChange[] asmRecipeChange)
+      {
+         if (asmRecipeChange == null) { return null; }
+         RecipeChange[] itacRecipeChange = new RecipeChange[asmRecipeChange.Length];
+         for (int i = 0; i < asmRecipeChange.Length; i++)
+         {
+            itacRecipeChange[i] = RecipeChangeMapper.get(asmRecipeChange[i]);
+         }
+         return itacRecipeChange;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/RecipeCollectionMapper.cs

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class RecipeCollectionMapper:MonitoringDataMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection get(RecipeCollection itacRecipeCollection)
+         {
+            if (itacRecipeCollection == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection asmRecipeCollection = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection();
+            mapItac2Asm(asmRecipeCollection, itacRecipeCollection);
+            return asmRecipeCollection;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection asmRecipeCollection, RecipeCollection itacRecipeCollection)
+      {
+         // skip readonly property RecipeLocations
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection[] get(RecipeCollection[] itacRecipeCollection)
+      {
+         if (itacRecipeCollection == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection[] asmRecipeCollection = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection[itacRecipeCollection.Length];
+         for (int i = 0; i < itacRecipeCollection.Length; i++)
+         {
+            // to itac array
+            asmRecipeCollection[i] = RecipeCollectionMapper.get(itacRecipeCollection[i]);
+         }
+         return asmRecipeCollection;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection> getList(RecipeCollection[] asmRecipeCollection)
+      {
+         if (asmRecipeCollection == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection> itacRecipeCollection = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection>();
+         for (int i = 0; i < asmRecipeCollection.Length; i++)
+         {
+            itacRecipeCollection.Add(RecipeCollectionMapper.get(asmRecipeCollection[i]));
+         }
+         return itacRecipeCollection;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static RecipeCollection get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection asmRecipeCollection)
+      {
+         if (asmRecipeCollection == null) { return null; }
+         RecipeCollection itacRecipeCollection = new RecipeCollection();
+         mapAsm2Itac(asmRecipeCollection, itacRecipeCollection);
+         return itacRecipeCollection;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection asmRecipeCollection, RecipeCollection itacRecipeCollection)
+      {
+         MonitoringDataMapper.mapAsm2Itac(asmRecipeCollection, itacRecipeCollection);
+         // maps ASM list 2 iTAC array
+         itacRecipeCollection.RecipeLocations = RecipeLocationMapper.getArray(asmRecipeCollection.RecipeLocations);
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static RecipeCollection[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection> asmRecipeCollection)
+      {
+         if (asmRecipeCollection == null) { return null; }
+         RecipeCollection[] itacRecipeCollection = new RecipeCollection[asmRecipeCollection.Count];
+         for (int i = 0; i < asmRecipeCollection.Count; i++)
+         {
+            itacRecipeCollection[i] = RecipeCollectionMapper.get(asmRecipeCollection[i]);
+         }
+         return itacRecipeCollection;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static RecipeCollection[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeCollection[] asmRecipeCollection)
+      {
+         if (asmRecipeCollection == null) { return null; }
+         RecipeCollection[] itacRecipeCollection = new RecipeCollection[asmRecipeCollection.Length];
+         for (int i = 0; i < asmRecipeCollection.Length; i++)
+         {
+            itacRecipeCollection[i] = RecipeCollectionMapper.get(asmRecipeCollection[i]);
+         }
+         return itacRecipeCollection;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/RecipeLocationMapper.cs

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class RecipeLocationMapper:ProcessingLocationAddressMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation get(RecipeLocation itacRecipeLocation)
+         {
+            if (itacRecipeLocation == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation asmRecipeLocation = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation();
+            mapItac2Asm(asmRecipeLocation, itacRecipeLocation);
+            return asmRecipeLocation;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation asmRecipeLocation, RecipeLocation itacRecipeLocation)
+      {
+         // skip readonly property Recipe
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation[] get(RecipeLocation[] itacRecipeLocation)
+      {
+         if (itacRecipeLocation == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation[] asmRecipeLocation = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation[itacRecipeLocation.Length];
+         for (int i = 0; i < itacRecipeLocation.Length; i++)
+         {
+            // to itac array
+            asmRecipeLocation[i] = RecipeLocationMapper.get(itacRecipeLocation[i]);
+         }
+         return asmRecipeLocation;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation> getList(RecipeLocation[] asmRecipeLocation)
+      {
+         if (asmRecipeLocation == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation> itacRecipeLocation = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation>();
+         for (int i = 0; i < asmRecipeLocation.Length; i++)
+         {
+            itacRecipeLocation.Add(RecipeLocationMapper.get(asmRecipeLocation[i]));
+         }
+         return itacRecipeLocation;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static RecipeLocation get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation asmRecipeLocation)
+      {
+         if (asmRecipeLocation == null) { return null; }
+         RecipeLocation itacRecipeLocation = new RecipeLocation();
+         mapAsm2Itac(asmRecipeLocation, itacRecipeLocation);
+         return itacRecipeLocation;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation asmRecipeLocation, RecipeLocation itacRecipeLocation)
+      {
+         ProcessingLocationAddressMapper.mapAsm2Itac(asmRecipeLocation, itacRecipeLocation);
+         itacRecipeLocation.Recipe = com.itac.oib.monitoring.contracts.data.RecipeMapper.get(asmRecipeLocation.Recipe);
+         // complex asm property Recipe
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static RecipeLocation[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation> asmRecipeLocation)
+      {
+         if (asmRecipeLocation == null) { return null; }
+         RecipeLocation[] itacRecipeLocation = new RecipeLocation[asmRecipeLocation.Count];
+         for (int i = 0; i < asmRecipeLocation.Count; i++)
+         {
+            itacRecipeLocation[i] = RecipeLocationMapper.get(asmRecipeLocation[i]);
+         }
+         return itacRecipeLocation;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static RecipeLocation[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.RecipeLocation[] asmRecipeLocation)
+      {
+         if (asmRecipeLocation == null) { return null; }
+         RecipeLocation[] itacRecipeLocation = new RecipeLocation[asmRecipeLocation.Length];
+         for (int i = 0; i < asmRecipeLocation.Length; i++)
+         {
+            itacRecipeLocation[i] = RecipeLocationMapper.get(asmRecipeLocation[i]);
+         }
+         return itacRecipeLocation;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/RecipeMapper.cs

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class RecipeMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe get(Recipe itacRecipe)
+         {
+            if (itacRecipe == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe asmRecipe = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe();
+            mapItac2Asm(asmRecipe, itacRecipe);
+            return asmRecipe;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe asmRecipe, Recipe itacRecipe)
+      {
+         asmRecipe.LineName = itacRecipe.LineName;
+         asmRecipe.LineFullPath = itacRecipe.LineFullPath;
+         asmRecipe.StationName = itacRecipe.StationName;
+         asmRecipe.StationFullPath = itacRecipe.StationFullPath;
+         asmRecipe.StartTime = itacRecipe.StartTime;
+         // complex property Conveyor, isArray:False, isGeneric:False
+         asmRecipe.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get( itacRecipe.Conveyor);
+         asmRecipe.RecipeName = itacRecipe.RecipeName;
+         asmRecipe.RecipeFullPath = itacRecipe.RecipeFullPath;
+         asmRecipe.SetupName = itacRecipe.SetupName;
+         asmRecipe.SetupFullPath = itacRecipe.SetupFullPath;
+         asmRecipe.CycleTime = itacRecipe.CycleTime;
+         asmRecipe.ComponentBarcode = itacRecipe.ComponentBarcode;
+         asmRecipe.StationCycleTimeValid = itacRecipe.StationCycleTimeValid;
+         asmRecipe.StationCycleTime = itacRecipe.StationCycleTime;
+         asmRecipe.ParallelProcessingFactor = itacRecipe.ParallelProcessingFactor;
+         asmRecipe.Bypassed = itacRecipe.Bypassed;
+         asmRecipe.OrderId = itacRecipe.OrderId;
+         // skip readonly property Heads
+         // skip readonly property TargetBoards
+         // skip readonly property TrackEntries
+         // skip readonly property RecipeAddOnEntries
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe[] get(Recipe[] itacRecipe)
+      {
+         if (itacRecipe == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe[] asmRecipe = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe[itacRecipe.Length];
+         for (int i = 0; i < itacRecipe.Length; i++)
+         {
+            // to itac array
+            asmRecipe[i] = RecipeMapper.get(itacRecipe[i]);
+         }
+         return asmRecipe;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe> getList(Recipe[] asmRecipe)
+      {
+         if (asmRecipe == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe> itacRecipe = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe>();
+         for (int i = 0; i < asmRecipe.Length; i++)
+         {
+            itacRecipe.Add(RecipeMapper.get(asmRecipe[i]));
+         }
+         return itacRecipe;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static Recipe get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe asmRecipe)
+      {
+         if (asmRecipe == null) { return null; }
+         Recipe itacRecipe = new Recipe();
+         mapAsm2Itac(asmRecipe, itacRecipe);
+         return itacRecipe;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe asmRecipe, Recipe itacRecipe)
+      {
+         itacRecipe.LineName = asmRecipe.LineName;
+         itacRecipe.LineFullPath = asmRecipe.LineFullPath;
+         itacRecipe.StationName = asmRecipe.StationName;
+         itacRecipe.StationFullPath = asmRecipe.StationFullPath;
+         itacRecipe.StartTime = asmRecipe.StartTime;
+         itacRecipe.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get(asmRecipe.Conveyor);
+         // complex asm property Conveyor
+         itacRecipe.RecipeName = asmRecipe.RecipeName;
+         itacRecipe.RecipeFullPath = asmRecipe.RecipeFullPath;
+         itacRecipe.SetupName = asmRecipe.SetupName;
+         itacRecipe.SetupFullPath = asmRecipe.SetupFullPath;
+         itacRecipe.CycleTime = asmRecipe.CycleTime;
+         itacRecipe.ComponentBarcode = asmRecipe.ComponentBarcode;
+         itacRecipe.StationCycleTimeValid = asmRecipe.StationCycleTimeValid;
+         itacRecipe.StationCycleTime = asmRecipe.StationCycleTime;
+         itacRecipe.ParallelProcessingFactor = asmRecipe.ParallelProcessingFactor;
+         itacRecipe.Bypassed = asmRecipe.Bypassed;
+         itacRecipe.OrderId = asmRecipe.OrderId;
+         // maps ASM list 2 iTAC array
+         itacRecipe.Heads = HeadMapper.getArray(asmRecipe.Heads);
+         // maps ASM list 2 iTAC array
+         itacRecipe.TargetBoards = TargetBoardMapper.getArray(asmRecipe.TargetBoards);
+         // maps ASM list 2 iTAC array
+         itacRecipe.TrackEntries = TrackEntryMapper.getArray(asmRecipe.TrackEntries);
+         // maps ASM list 2 iTAC array
+         itacRecipe.RecipeAddOnEntries = RecipeAddOnMapper.getArray(asmRecipe.RecipeAddOnEntries);
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static Recipe[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe> asmRecipe)
+      {
+         if (asmRecipe == null) { return null; }
+         Recipe[] itacRecipe = new Recipe[asmRecipe.Count];
+         for (int i = 0; i < asmRecipe.Count; i++)
+         {
+            itacRecipe[i] = RecipeMapper.get(asmRecipe[i]);
+         }
+         return itacRecipe;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static Recipe[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Recipe[] asmRecipe)
+      {
+         if (asmRecipe == null) { return null; }
+         Recipe[] itacRecipe = new Recipe[asmRecipe.Length];
+         for (int i = 0; i < asmRecipe.Length; i++)
+         {
+            itacRecipe[i] = RecipeMapper.get(asmRecipe[i]);
+         }
+         return itacRecipe;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/SetupCollectionMapper.cs

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class SetupCollectionMapper:MonitoringDataMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection get(SetupCollection itacSetupCollection)
+         {
+            if (itacSetupCollection == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection asmSetupCollection = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection();
+            mapItac2Asm(asmSetupCollection, itacSetupCollection);
+            return asmSetupCollection;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection asmSetupCollection, SetupCollection itacSetupCollection)
+      {
+         // skip readonly property TrackEntries
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection[] get(SetupCollection[] itacSetupCollection)
+      {
+         if (itacSetupCollection == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection[] asmSetupCollection = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection[itacSetupCollection.Length];
+         for (int i = 0; i < itacSetupCollection.Length; i++)
+         {
+            // to itac array
+            asmSetupCollection[i] = SetupCollectionMapper.get(itacSetupCollection[i]);
+         }
+         return asmSetupCollection;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection> getList(SetupCollection[] asmSetupCollection)
+      {
+         if (asmSetupCollection == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection> itacSetupCollection = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection>();
+         for (int i = 0; i < asmSetupCollection.Length; i++)
+         {
+            itacSetupCollection.Add(SetupCollectionMapper.get(asmSetupCollection[i]));
+         }
+         return itacSetupCollection;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static SetupCollection get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection asmSetupCollection)
+      {
+         if (asmSetupCollection == null) { return null; }
+         SetupCollection itacSetupCollection = new SetupCollection();
+         mapAsm2Itac(asmSetupCollection, itacSetupCollection);
+         return itacSetupCollection;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection asmSetupCollection, SetupCollection itacSetupCollection)
+      {
+         MonitoringDataMapper.mapAsm2Itac(asmSetupCollection, itacSetupCollection);
+         // maps ASM list 2 iTAC array
+         itacSetupCollection.TrackEntries = TrackEntryMapper.getArray(asmSetupCollection.TrackEntries);
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static SetupCollection[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection> asmSetupCollection)
+      {
+         if (asmSetupCollection == null) { return null; }
+         SetupCollection[] itacSetupCollection = new SetupCollection[asmSetupCollection.Count];
+         for (int i = 0; i < asmSetupCollection.Count; i++)
+         {
+            itacSetupCollection[i] = SetupCollectionMapper.get(asmSetupCollection[i]);
+         }
+         return itacSetupCollection;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static SetupCollection[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.SetupCollection[] asmSetupCollection)
+      {
+         if (asmSetupCollection == null) { return null; }
+         SetupCollection[] itacSetupCollection = new SetupCollection[asmSetupCollection.Length];
+         for (int i = 0; i < asmSetupCollection.Length; i++)
+         {
+            itacSetupCollection[i] = SetupCollectionMapper.get(asmSetupCollection[i]);
+         }
+         return itacSetupCollection;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/StateTransitionMapper.cs

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class StateTransitionMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition get(StateTransition itacStateTransition)
+         {
+            if (itacStateTransition == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition asmStateTransition = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition();
+            mapItac2Asm(asmStateTransition, itacStateTransition);
+            return asmStateTransition;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition asmStateTransition, StateTransition itacStateTransition)
+      {
+         asmStateTransition.ProcessingArea = itacStateTransition.ProcessingArea;
+         // complex property StationState, isArray:False, isGeneric:False
+         asmStateTransition.StationState = com.itac.oib.monitoring.contracts.data.StationStateTypeMapper.get( itacStateTransition.StationState);
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition[] get(StateTransition[] itacStateTransition)
+      {
+         if (itacStateTransition == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition[] asmStateTransition = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition[itacStateTransition.Length];
+         for (int i = 0; i < itacStateTransition.Length; i++)
+         {
+            // to itac array
+            asmStateTransition[i] = StateTransitionMapper.get(itacStateTransition[i]);
+         }
+         return asmStateTransition;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition> getList(StateTransition[] asmStateTransition)
+      {
+         if (asmStateTransition == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition> itacStateTransition = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition>();
+         for (int i = 0; i < asmStateTransition.Length; i++)
+         {
+            itacStateTransition.Add(StateTransitionMapper.get(asmStateTransition[i]));
+         }
+         return itacStateTransition;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static StateTransition get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition asmStateTransition)
+      {
+         if (asmStateTransition == null) { return null; }
+         StateTransition itacStateTransition = new StateTransition();
+         mapAsm2Itac(asmStateTransition, itacStateTransition);
+         return itacStateTransition;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition asmStateTransition, StateTransition itacStateTransition)
+      {
+         itacStateTransition.ProcessingArea = asmStateTransition.ProcessingArea;
+         itacStateTransition.StationState = com.itac.oib.monitoring.contracts.data.StationStateTypeMapper.get(asmStateTransition.StationState);
+         // complex asm property StationState
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static StateTransition[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition> asmStateTransition)
+      {
+         if (asmStateTransition == null) { return null; }
+         StateTransition[] itacStateTransition = new StateTransition[asmStateTransition.Count];
+         for (int i = 0; i < asmStateTransition.Count; i++)
+         {
+            itacStateTransition[i] = StateTransitionMapper.get(asmStateTransition[i]);
+         }
+         return itacStateTransition;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static StateTransition[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.StateTransition[] asmStateTransition)
+      {
+         if (asmStateTransition == null) { return null; }
+         StateTransition[] itacStateTransition = new StateTransition[asmStateTransition.Length];
+         for (int i = 0; i < asmStateTransition.Length; i++)
+         {
+            itacStateTransition[i] = StateTransitionMapper.get(asmStateTransition[i]);
+         }
+         return itacStateTransition;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/StationBaseMapper.cs

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class StationBaseMapper:MonitoringDataMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+   /*      public static Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase get(StationBase itacStationBase)
+         {
+            if (itacStationBase == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase asmStationBase = new Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase(Asm.As.Oib.SiplacePro.Proxy.Business.Types.ResourceIDs.AttachableheadtypeCp_20);
+            mapItac2Asm(asmStationBase, itacStationBase);
+            return asmStationBase;
+         }
+         */
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase asmStationBase, StationBase itacStationBase)
+      {
+         // skip readonly property Station
+         // complex property CompletionStatusType, isArray:False, isGeneric:False
+         asmStationBase.CompletionStatusType = com.itac.oib.monitoring.contracts.data.CompletionStatusTypeMapper.get( itacStationBase.CompletionStatusType);
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase[] get(StationBase[] itacStationBase)
+      {
+         if (itacStationBase == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase[] asmStationBase = new Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase[itacStationBase.Length];
+         for (int i = 0; i < itacStationBase.Length; i++)
+         {
+            // to itac array
+   //         asmStationBase[i] = StationBaseMapper.get(itacStationBase[i]);
+         }
+         return asmStationBase;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase> getList(StationBase[] asmStationBase)
+      {
+         if (asmStationBase == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase> itacStationBase = new List<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase>();
+         for (int i = 0; i < asmStationBase.Length; i++)
+         {
+  //          itacStationBase.Add(StationBaseMapper.get(asmStationBase[i]));
+         }
+         return itacStationBase;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static StationBase get(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase asmStationBase)
+      {
+         if (asmStationBase == null) { return null; }
+         StationBase itacStationBase = new StationBase();
+         mapAsm2Itac(asmStationBase, itacStationBase);
+         return itacStationBase;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase asmStationBase, StationBase itacStationBase)
+      {
+         MonitoringDataMapper.mapAsm2Itac(asmStationBase, itacStationBase);
+         itacStationBase.Station = com.itac.oib.monitoring.contracts.data.StationMapper.get(asmStationBase.Station);
+         // complex asm property Station
+         itacStationBase.CompletionStatusType = com.itac.oib.monitoring.contracts.data.CompletionStatusTypeMapper.get(asmStationBase.CompletionStatusType);
+         // complex asm property CompletionStatusType
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static StationBase[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase> asmStationBase)
+      {
+         if (asmStationBase == null) { return null; }
+         StationBase[] itacStationBase = new StationBase[asmStationBase.Count];
+         for (int i = 0; i < asmStationBase.Count; i++)
+         {
+            itacStationBase[i] = StationBaseMapper.get(asmStationBase[i]);
+         }
+         return itacStationBase;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static StationBase[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.BaseClasses.StationBase[] asmStationBase)
+      {
+         if (asmStationBase == null) { return null; }
+         StationBase[] itacStationBase = new StationBase[asmStationBase.Length];
+         for (int i = 0; i < asmStationBase.Length; i++)
+         {
+            itacStationBase[i] = StationBaseMapper.get(asmStationBase[i]);
+         }
+         return itacStationBase;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/StationEventCompositeMapper.cs

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class StationEventCompositeMapper:StationBaseMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite get(StationEventComposite itacStationEventComposite)
+         {
+            if (itacStationEventComposite == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite asmStationEventComposite = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite();
+            mapItac2Asm(asmStationEventComposite, itacStationEventComposite);
+            return asmStationEventComposite;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite asmStationEventComposite, StationEventComposite itacStationEventComposite)
+      {
+         // skip readonly property StateTransitions
+         // skip readonly property ProcessingLocationStates
+         // skip readonly property GantryStates
+         asmStationEventComposite.BoardNumber = itacStationEventComposite.BoardNumber;
+         asmStationEventComposite.StationTime = itacStationEventComposite.StationTime;
+         // complex property Conveyor, isArray:False, isGeneric:False
+         asmStationEventComposite.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get( itacStationEventComposite.Conveyor);
+         // complex property StationEventType, isArray:False, isGeneric:False
+         asmStationEventComposite.StationEventType = com.itac.oib.monitoring.contracts.data.StationEventTypeMapper.get( itacStationEventComposite.StationEventType);
+         asmStationEventComposite.ProcessingArea = itacStationEventComposite.ProcessingArea;
+         // complex property ProcessingMode, isArray:False, isGeneric:False
+         asmStationEventComposite.ProcessingMode = com.itac.oib.monitoring.contracts.data.ProcessingModeTypeMapper.get( itacStationEventComposite.ProcessingMode);
+         // complex property SubConveyor, isArray:False, isGeneric:False
+         asmStationEventComposite.SubConveyor = com.itac.oib.monitoring.contracts.data.SubConveyorTypeMapper.get( itacStationEventComposite.SubConveyor);
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite[] get(StationEventComposite[] itacStationEventComposite)
+      {
+         if (itacStationEventComposite == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite[] asmStationEventComposite = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite[itacStationEventComposite.Length];
+         for (int i = 0; i < itacStationEventComposite.Length; i++)
+         {
+            // to itac array
+            asmStationEventComposite[i] = StationEventCompositeMapper.get(itacStationEventComposite[i]);
+         }
+         return asmStationEventComposite;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite> getList(StationEventComposite[] asmStationEventComposite)
+      {
+         if (asmStationEventComposite == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite> itacStationEventComposite = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite>();
+         for (int i = 0; i < asmStationEventComposite.Length; i++)
+         {
+            itacStationEventComposite.Add(StationEventCompositeMapper.get(asmStationEventComposite[i]));
+         }
+         return itacStationEventComposite;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static StationEventComposite get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite asmStationEventComposite)
+      {
+         if (asmStationEventComposite == null) { return null; }
+         StationEventComposite itacStationEventComposite = new StationEventComposite();
+         mapAsm2Itac(asmStationEventComposite, itacStationEventComposite);
+         return itacStationEventComposite;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite asmStationEventComposite, StationEventComposite itacStationEventComposite)
+      {
+         StationBaseMapper.mapAsm2Itac(asmStationEventComposite, itacStationEventComposite);
+         // maps ASM list 2 iTAC array
+         itacStationEventComposite.StateTransitions = StateTransitionMapper.getArray(asmStationEventComposite.StateTransitions);
+         // maps ASM list 2 iTAC array
+         itacStationEventComposite.ProcessingLocationStates = ProcessingLocationStateMapper.getArray(asmStationEventComposite.ProcessingLocationStates);
+         // maps ASM list 2 iTAC array
+         itacStationEventComposite.GantryStates = GantryStateMapper.getArray(asmStationEventComposite.GantryStates);
+         itacStationEventComposite.BoardNumber = asmStationEventComposite.BoardNumber;
+         itacStationEventComposite.StationTime = asmStationEventComposite.StationTime;
+         itacStationEventComposite.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get(asmStationEventComposite.Conveyor);
+         // complex asm property Conveyor
+         itacStationEventComposite.StationEventType = com.itac.oib.monitoring.contracts.data.StationEventTypeMapper.get(asmStationEventComposite.StationEventType);
+         // complex asm property StationEventType
+         itacStationEventComposite.ProcessingArea = asmStationEventComposite.ProcessingArea;
+         itacStationEventComposite.ProcessingMode = com.itac.oib.monitoring.contracts.data.ProcessingModeTypeMapper.get(asmStationEventComposite.ProcessingMode);
+         // complex asm property ProcessingMode
+         itacStationEventComposite.SubConveyor = com.itac.oib.monitoring.contracts.data.SubConveyorTypeMapper.get(asmStationEventComposite.SubConveyor);
+         // complex asm property SubConveyor
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static StationEventComposite[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite> asmStationEventComposite)
+      {
+         if (asmStationEventComposite == null) { return null; }
+         StationEventComposite[] itacStationEventComposite = new StationEventComposite[asmStationEventComposite.Count];
+         for (int i = 0; i < asmStationEventComposite.Count; i++)
+         {
+            itacStationEventComposite[i] = StationEventCompositeMapper.get(asmStationEventComposite[i]);
+         }
+         return itacStationEventComposite;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static StationEventComposite[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEventComposite[] asmStationEventComposite)
+      {
+         if (asmStationEventComposite == null) { return null; }
+         StationEventComposite[] itacStationEventComposite = new StationEventComposite[asmStationEventComposite.Length];
+         for (int i = 0; i < asmStationEventComposite.Length; i++)
+         {
+            itacStationEventComposite[i] = StationEventCompositeMapper.get(asmStationEventComposite[i]);
+         }
+         return itacStationEventComposite;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/StationEventMapper.cs

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class StationEventMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent get(StationEvent itacStationEvent)
+         {
+            if (itacStationEvent == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent asmStationEvent = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent();
+            mapItac2Asm(asmStationEvent, itacStationEvent);
+            return asmStationEvent;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent asmStationEvent, StationEvent itacStationEvent)
+      {
+         asmStationEvent.BoardNumber = itacStationEvent.BoardNumber;
+         asmStationEvent.StationTime = itacStationEvent.StationTime;
+         // complex property Conveyor, isArray:False, isGeneric:False
+         asmStationEvent.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get( itacStationEvent.Conveyor);
+         // complex property StationEventType, isArray:False, isGeneric:False
+         asmStationEvent.StationEventType = com.itac.oib.monitoring.contracts.data.StationEventTypeMapper.get( itacStationEvent.StationEventType);
+         asmStationEvent.ProcessingArea = itacStationEvent.ProcessingArea;
+         // complex property ProcessingMode, isArray:False, isGeneric:False
+         asmStationEvent.ProcessingMode = com.itac.oib.monitoring.contracts.data.ProcessingModeTypeMapper.get( itacStationEvent.ProcessingMode);
+         // complex property SubConveyor, isArray:False, isGeneric:False
+         asmStationEvent.SubConveyor = com.itac.oib.monitoring.contracts.data.SubConveyorTypeMapper.get( itacStationEvent.SubConveyor);
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent[] get(StationEvent[] itacStationEvent)
+      {
+         if (itacStationEvent == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent[] asmStationEvent = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent[itacStationEvent.Length];
+         for (int i = 0; i < itacStationEvent.Length; i++)
+         {
+            // to itac array
+            asmStationEvent[i] = StationEventMapper.get(itacStationEvent[i]);
+         }
+         return asmStationEvent;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent> getList(StationEvent[] asmStationEvent)
+      {
+         if (asmStationEvent == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent> itacStationEvent = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent>();
+         for (int i = 0; i < asmStationEvent.Length; i++)
+         {
+            itacStationEvent.Add(StationEventMapper.get(asmStationEvent[i]));
+         }
+         return itacStationEvent;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static StationEvent get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent asmStationEvent)
+      {
+         if (asmStationEvent == null) { return null; }
+         StationEvent itacStationEvent = new StationEvent();
+         mapAsm2Itac(asmStationEvent, itacStationEvent);
+         return itacStationEvent;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent asmStationEvent, StationEvent itacStationEvent)
+      {
+         itacStationEvent.BoardNumber = asmStationEvent.BoardNumber;
+         itacStationEvent.StationTime = asmStationEvent.StationTime;
+         itacStationEvent.Conveyor = com.itac.oib.monitoring.contracts.data.ConveyorTypeMapper.get(asmStationEvent.Conveyor);
+         // complex asm property Conveyor
+         itacStationEvent.StationEventType = com.itac.oib.monitoring.contracts.data.StationEventTypeMapper.get(asmStationEvent.StationEventType);
+         // complex asm property StationEventType
+         itacStationEvent.ProcessingArea = asmStationEvent.ProcessingArea;
+         itacStationEvent.ProcessingMode = com.itac.oib.monitoring.contracts.data.ProcessingModeTypeMapper.get(asmStationEvent.ProcessingMode);
+         // complex asm property ProcessingMode
+         itacStationEvent.SubConveyor = com.itac.oib.monitoring.contracts.data.SubConveyorTypeMapper.get(asmStationEvent.SubConveyor);
+         // complex asm property SubConveyor
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static StationEvent[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent> asmStationEvent)
+      {
+         if (asmStationEvent == null) { return null; }
+         StationEvent[] itacStationEvent = new StationEvent[asmStationEvent.Count];
+         for (int i = 0; i < asmStationEvent.Count; i++)
+         {
+            itacStationEvent[i] = StationEventMapper.get(asmStationEvent[i]);
+         }
+         return itacStationEvent;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static StationEvent[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.StationEvent[] asmStationEvent)
+      {
+         if (asmStationEvent == null) { return null; }
+         StationEvent[] itacStationEvent = new StationEvent[asmStationEvent.Length];
+         for (int i = 0; i < asmStationEvent.Length; i++)
+         {
+            itacStationEvent[i] = StationEventMapper.get(asmStationEvent[i]);
+         }
+         return itacStationEvent;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/StationEventTypeMapper.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:59
+using System;
+using System.Collections.Generic;
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class StationEventTypeMapper
+   {
+
+      // map asm enum value to itac enum value
+      public static StationEventType get(Asm.As.Oib.Monitoring.Proxy.Business.Types.StationEventType stationEventType)
+      {
+         int intValue = (int)stationEventType;
+         return (StationEventType)intValue;
+      }
+
+      // map itac enum value to ASM enum value
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Types.StationEventType get(StationEventType stationEventType)
+      {
+         int intValue = (int)stationEventType;
+         return (Asm.As.Oib.Monitoring.Proxy.Business.Types.StationEventType)intValue;
+      }
+   }
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/StationMapper.cs

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class StationMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station get(Station itacStation)
+         {
+            if (itacStation == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station asmStation = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station();
+            mapItac2Asm(asmStation, itacStation);
+            return asmStation;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station asmStation, Station itacStation)
+      {
+         asmStation.LineName = itacStation.LineName;
+         asmStation.LineFullPath = itacStation.LineFullPath;
+         asmStation.Name = itacStation.Name;
+         asmStation.FullPath = itacStation.FullPath;
+         asmStation.ProcessingAreaCount = itacStation.ProcessingAreaCount;
+         asmStation.Text = itacStation.Text;
+         asmStation.ComputerAddress = itacStation.ComputerAddress;
+         asmStation.MachineId = itacStation.MachineId;
+         asmStation.SoftwareVersion = itacStation.SoftwareVersion;
+         asmStation.TypeName = itacStation.TypeName;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station[] get(Station[] itacStation)
+      {
+         if (itacStation == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station[] asmStation = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station[itacStation.Length];
+         for (int i = 0; i < itacStation.Length; i++)
+         {
+            // to itac array
+            asmStation[i] = StationMapper.get(itacStation[i]);
+         }
+         return asmStation;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station> getList(Station[] asmStation)
+      {
+         if (asmStation == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station> itacStation = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station>();
+         for (int i = 0; i < asmStation.Length; i++)
+         {
+            itacStation.Add(StationMapper.get(asmStation[i]));
+         }
+         return itacStation;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static Station get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station asmStation)
+      {
+         if (asmStation == null) { return null; }
+         Station itacStation = new Station();
+         mapAsm2Itac(asmStation, itacStation);
+         return itacStation;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station asmStation, Station itacStation)
+      {
+         itacStation.LineName = asmStation.LineName;
+         itacStation.LineFullPath = asmStation.LineFullPath;
+         itacStation.Name = asmStation.Name;
+         itacStation.FullPath = asmStation.FullPath;
+         itacStation.ProcessingAreaCount = asmStation.ProcessingAreaCount;
+         itacStation.Text = asmStation.Text;
+         itacStation.ComputerAddress = asmStation.ComputerAddress;
+         itacStation.MachineId = asmStation.MachineId;
+         itacStation.SoftwareVersion = asmStation.SoftwareVersion;
+         itacStation.TypeName = asmStation.TypeName;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static Station[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station> asmStation)
+      {
+         if (asmStation == null) { return null; }
+         Station[] itacStation = new Station[asmStation.Count];
+         for (int i = 0; i < asmStation.Count; i++)
+         {
+            itacStation[i] = StationMapper.get(asmStation[i]);
+         }
+         return itacStation;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static Station[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.Station[] asmStation)
+      {
+         if (asmStation == null) { return null; }
+         Station[] itacStation = new Station[asmStation.Length];
+         for (int i = 0; i < asmStation.Length; i++)
+         {
+            itacStation[i] = StationMapper.get(asmStation[i]);
+         }
+         return itacStation;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/StationStateTypeMapper.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:59
+using System;
+using System.Collections.Generic;
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class StationStateTypeMapper
+   {
+
+      // map asm enum value to itac enum value
+      public static StationStateType get(Asm.As.Oib.Monitoring.Proxy.Business.Types.StationStateType stationStateType)
+      {
+         int intValue = (int)stationStateType;
+         return (StationStateType)intValue;
+      }
+
+      // map itac enum value to ASM enum value
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Types.StationStateType get(StationStateType stationStateType)
+      {
+         int intValue = (int)stationStateType;
+         return (Asm.As.Oib.Monitoring.Proxy.Business.Types.StationStateType)intValue;
+      }
+   }
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/SubConveyorTypeMapper.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:59
+using System;
+using System.Collections.Generic;
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class SubConveyorTypeMapper
+   {
+
+      // map asm enum value to itac enum value
+      public static SubConveyorType get(Asm.As.Oib.Monitoring.Proxy.Business.Types.SubConveyorType subConveyorType)
+      {
+         int intValue = (int)subConveyorType;
+         return (SubConveyorType)intValue;
+      }
+
+      // map itac enum value to ASM enum value
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Types.SubConveyorType get(SubConveyorType subConveyorType)
+      {
+         int intValue = (int)subConveyorType;
+         return (Asm.As.Oib.Monitoring.Proxy.Business.Types.SubConveyorType)intValue;
+      }
+   }
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/TargetBoardMapper.cs

@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class TargetBoardMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard get(TargetBoard itacTargetBoard)
+         {
+            if (itacTargetBoard == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard asmTargetBoard = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard();
+            mapItac2Asm(asmTargetBoard, itacTargetBoard);
+            return asmTargetBoard;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard asmTargetBoard, TargetBoard itacTargetBoard)
+      {
+         asmTargetBoard.LotSize = itacTargetBoard.LotSize;
+         asmTargetBoard.BoardName = itacTargetBoard.BoardName;
+         asmTargetBoard.BoardFullPath = itacTargetBoard.BoardFullPath;
+         asmTargetBoard.OrderId = itacTargetBoard.OrderId;
+         // complex property BoardSide, isArray:False, isGeneric:False
+         asmTargetBoard.BoardSide = com.itac.oib.monitoring.contracts.data.BoardSideTypeMapper.get( itacTargetBoard.BoardSide);
+         // complex property SubConveyor, isArray:False, isGeneric:False
+         asmTargetBoard.SubConveyor = com.itac.oib.monitoring.contracts.data.SubConveyorTypeMapper.get( itacTargetBoard.SubConveyor);
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard[] get(TargetBoard[] itacTargetBoard)
+      {
+         if (itacTargetBoard == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard[] asmTargetBoard = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard[itacTargetBoard.Length];
+         for (int i = 0; i < itacTargetBoard.Length; i++)
+         {
+            // to itac array
+            asmTargetBoard[i] = TargetBoardMapper.get(itacTargetBoard[i]);
+         }
+         return asmTargetBoard;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard> getList(TargetBoard[] asmTargetBoard)
+      {
+         if (asmTargetBoard == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard> itacTargetBoard = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard>();
+         for (int i = 0; i < asmTargetBoard.Length; i++)
+         {
+            itacTargetBoard.Add(TargetBoardMapper.get(asmTargetBoard[i]));
+         }
+         return itacTargetBoard;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static TargetBoard get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard asmTargetBoard)
+      {
+         if (asmTargetBoard == null) { return null; }
+         TargetBoard itacTargetBoard = new TargetBoard();
+         mapAsm2Itac(asmTargetBoard, itacTargetBoard);
+         return itacTargetBoard;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard asmTargetBoard, TargetBoard itacTargetBoard)
+      {
+         itacTargetBoard.LotSize = asmTargetBoard.LotSize;
+         itacTargetBoard.BoardName = asmTargetBoard.BoardName;
+         itacTargetBoard.BoardFullPath = asmTargetBoard.BoardFullPath;
+         itacTargetBoard.OrderId = asmTargetBoard.OrderId;
+         itacTargetBoard.BoardSide = com.itac.oib.monitoring.contracts.data.BoardSideTypeMapper.get(asmTargetBoard.BoardSide);
+         // complex asm property BoardSide
+         itacTargetBoard.SubConveyor = com.itac.oib.monitoring.contracts.data.SubConveyorTypeMapper.get(asmTargetBoard.SubConveyor);
+         // complex asm property SubConveyor
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static TargetBoard[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard> asmTargetBoard)
+      {
+         if (asmTargetBoard == null) { return null; }
+         TargetBoard[] itacTargetBoard = new TargetBoard[asmTargetBoard.Count];
+         for (int i = 0; i < asmTargetBoard.Count; i++)
+         {
+            itacTargetBoard[i] = TargetBoardMapper.get(asmTargetBoard[i]);
+         }
+         return itacTargetBoard;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static TargetBoard[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.TargetBoard[] asmTargetBoard)
+      {
+         if (asmTargetBoard == null) { return null; }
+         TargetBoard[] itacTargetBoard = new TargetBoard[asmTargetBoard.Length];
+         for (int i = 0; i < asmTargetBoard.Length; i++)
+         {
+            itacTargetBoard[i] = TargetBoardMapper.get(asmTargetBoard[i]);
+         }
+         return itacTargetBoard;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/TrackEntryMapper.cs

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+using com.itac.oib.monitoring.contracts.data;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class TrackEntryMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry get(TrackEntry itacTrackEntry)
+         {
+            if (itacTrackEntry == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry asmTrackEntry = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry();
+            mapItac2Asm(asmTrackEntry, itacTrackEntry);
+            return asmTrackEntry;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry asmTrackEntry, TrackEntry itacTrackEntry)
+      {
+         asmTrackEntry.TableLocation = itacTrackEntry.TableLocation;
+         asmTrackEntry.Track = itacTrackEntry.Track;
+         asmTrackEntry.Tower = itacTrackEntry.Tower;
+         asmTrackEntry.Level = itacTrackEntry.Level;
+         asmTrackEntry.Division = itacTrackEntry.Division;
+         asmTrackEntry.FeederType = itacTrackEntry.FeederType;
+         asmTrackEntry.ComponentName = itacTrackEntry.ComponentName;
+         asmTrackEntry.ComponentFullPath = itacTrackEntry.ComponentFullPath;
+         asmTrackEntry.ComponentShapeName = itacTrackEntry.ComponentShapeName;
+         asmTrackEntry.ComponentShapeFullPath = itacTrackEntry.ComponentShapeFullPath;
+         asmTrackEntry.FeederLongType = itacTrackEntry.FeederLongType;
+         asmTrackEntry.FeederTypeName = itacTrackEntry.FeederTypeName;
+         asmTrackEntry.TableTypeName = itacTrackEntry.TableTypeName;
+         // complex property Used, isArray:False, isGeneric:False
+         asmTrackEntry.Used = com.itac.oib.monitoring.contracts.data.UsedTypeMapper.get( itacTrackEntry.Used);
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry[] get(TrackEntry[] itacTrackEntry)
+      {
+         if (itacTrackEntry == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry[] asmTrackEntry = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry[itacTrackEntry.Length];
+         for (int i = 0; i < itacTrackEntry.Length; i++)
+         {
+            // to itac array
+            asmTrackEntry[i] = TrackEntryMapper.get(itacTrackEntry[i]);
+         }
+         return asmTrackEntry;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry> getList(TrackEntry[] asmTrackEntry)
+      {
+         if (asmTrackEntry == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry> itacTrackEntry = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry>();
+         for (int i = 0; i < asmTrackEntry.Length; i++)
+         {
+            itacTrackEntry.Add(TrackEntryMapper.get(asmTrackEntry[i]));
+         }
+         return itacTrackEntry;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static TrackEntry get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry asmTrackEntry)
+      {
+         if (asmTrackEntry == null) { return null; }
+         TrackEntry itacTrackEntry = new TrackEntry();
+         mapAsm2Itac(asmTrackEntry, itacTrackEntry);
+         return itacTrackEntry;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry asmTrackEntry, TrackEntry itacTrackEntry)
+      {
+         itacTrackEntry.TableLocation = asmTrackEntry.TableLocation;
+         itacTrackEntry.Track = asmTrackEntry.Track;
+         itacTrackEntry.Tower = asmTrackEntry.Tower;
+         itacTrackEntry.Level = asmTrackEntry.Level;
+         itacTrackEntry.Division = asmTrackEntry.Division;
+         itacTrackEntry.FeederType = asmTrackEntry.FeederType;
+         itacTrackEntry.ComponentName = asmTrackEntry.ComponentName;
+         itacTrackEntry.ComponentFullPath = asmTrackEntry.ComponentFullPath;
+         itacTrackEntry.ComponentShapeName = asmTrackEntry.ComponentShapeName;
+         itacTrackEntry.ComponentShapeFullPath = asmTrackEntry.ComponentShapeFullPath;
+         itacTrackEntry.FeederLongType = asmTrackEntry.FeederLongType;
+         itacTrackEntry.FeederTypeName = asmTrackEntry.FeederTypeName;
+         itacTrackEntry.TableTypeName = asmTrackEntry.TableTypeName;
+         itacTrackEntry.Used = com.itac.oib.monitoring.contracts.data.UsedTypeMapper.get(asmTrackEntry.Used);
+         // complex asm property Used
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static TrackEntry[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry> asmTrackEntry)
+      {
+         if (asmTrackEntry == null) { return null; }
+         TrackEntry[] itacTrackEntry = new TrackEntry[asmTrackEntry.Count];
+         for (int i = 0; i < asmTrackEntry.Count; i++)
+         {
+            itacTrackEntry[i] = TrackEntryMapper.get(asmTrackEntry[i]);
+         }
+         return itacTrackEntry;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static TrackEntry[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.TrackEntry[] asmTrackEntry)
+      {
+         if (asmTrackEntry == null) { return null; }
+         TrackEntry[] itacTrackEntry = new TrackEntry[asmTrackEntry.Length];
+         for (int i = 0; i < asmTrackEntry.Length; i++)
+         {
+            itacTrackEntry[i] = TrackEntryMapper.get(asmTrackEntry[i]);
+         }
+         return itacTrackEntry;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/UsedDetailMapper.cs

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:33
+using System;
+using System.Collections.Generic;
+
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class UsedDetailMapper
+   {
+      // used for itac->asm: True
+      // used for asm->itac: True
+
+         // maps iTAC namespace conform type to ASM namespace type
+         public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail get(UsedDetail itacUsedDetail)
+         {
+            if (itacUsedDetail == null) { return null; }
+            Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail asmUsedDetail = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail();
+            mapItac2Asm(asmUsedDetail, itacUsedDetail);
+            return asmUsedDetail;
+         }
+
+      public static void mapItac2Asm(Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail asmUsedDetail, UsedDetail itacUsedDetail)
+      {
+         asmUsedDetail.AccessTotal = itacUsedDetail.AccessTotal;
+         asmUsedDetail.RejectIdent = itacUsedDetail.RejectIdent;
+         asmUsedDetail.RejectVacuum = itacUsedDetail.RejectVacuum;
+         // complex property TrackEntry, isArray:False, isGeneric:False
+         asmUsedDetail.TrackEntry = com.itac.oib.monitoring.contracts.data.TrackEntryMapper.get( itacUsedDetail.TrackEntry);
+         asmUsedDetail.TrackEmpty = itacUsedDetail.TrackEmpty;
+         asmUsedDetail.FeederId = itacUsedDetail.FeederId;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace array
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail[] get(UsedDetail[] itacUsedDetail)
+      {
+         if (itacUsedDetail == null) { return null; }
+         Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail[] asmUsedDetail = new Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail[itacUsedDetail.Length];
+         for (int i = 0; i < itacUsedDetail.Length; i++)
+         {
+            // to itac array
+            asmUsedDetail[i] = UsedDetailMapper.get(itacUsedDetail[i]);
+         }
+         return asmUsedDetail;
+      }
+
+      // maps iTAC namespace conform array to ASM namespace list
+      public static List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail> getList(UsedDetail[] asmUsedDetail)
+      {
+         if (asmUsedDetail == null) { return null; }
+         List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail> itacUsedDetail = new List<Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail>();
+         for (int i = 0; i < asmUsedDetail.Length; i++)
+         {
+            itacUsedDetail.Add(UsedDetailMapper.get(asmUsedDetail[i]));
+         }
+         return itacUsedDetail;
+      }
+
+      // map type from ASM namespace to iTAC namespace
+      public static UsedDetail get(Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail asmUsedDetail)
+      {
+         if (asmUsedDetail == null) { return null; }
+         UsedDetail itacUsedDetail = new UsedDetail();
+         mapAsm2Itac(asmUsedDetail, itacUsedDetail);
+         return itacUsedDetail;
+      }
+
+      public static void mapAsm2Itac(Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail asmUsedDetail, UsedDetail itacUsedDetail)
+      {
+         itacUsedDetail.AccessTotal = asmUsedDetail.AccessTotal;
+         itacUsedDetail.RejectIdent = asmUsedDetail.RejectIdent;
+         itacUsedDetail.RejectVacuum = asmUsedDetail.RejectVacuum;
+         itacUsedDetail.TrackEntry = com.itac.oib.monitoring.contracts.data.TrackEntryMapper.get(asmUsedDetail.TrackEntry);
+         // complex asm property TrackEntry
+         itacUsedDetail.TrackEmpty = asmUsedDetail.TrackEmpty;
+         itacUsedDetail.FeederId = asmUsedDetail.FeederId;
+      }
+
+      // maps ASM namespace conform list to iTAC namespace array
+      public static UsedDetail[] getArray(IList<Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail> asmUsedDetail)
+      {
+         if (asmUsedDetail == null) { return null; }
+         UsedDetail[] itacUsedDetail = new UsedDetail[asmUsedDetail.Count];
+         for (int i = 0; i < asmUsedDetail.Count; i++)
+         {
+            itacUsedDetail[i] = UsedDetailMapper.get(asmUsedDetail[i]);
+         }
+         return itacUsedDetail;
+      }
+
+      // maps ASM namespace conform array to iTAC namespace array
+      public static UsedDetail[] getArray(Asm.As.Oib.Monitoring.Proxy.Business.Objects.UsedDetail[] asmUsedDetail)
+      {
+         if (asmUsedDetail == null) { return null; }
+         UsedDetail[] itacUsedDetail = new UsedDetail[asmUsedDetail.Length];
+         for (int i = 0; i < asmUsedDetail.Length; i++)
+         {
+            itacUsedDetail[i] = UsedDetailMapper.get(asmUsedDetail[i]);
+         }
+         return itacUsedDetail;
+      }
+}
+}

interface/asm/dotnet/Oib3xMapper/generated_src/com.itac.oib.monitoring.contracts.data/UsedTypeMapper.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 iTAC Software AG, Germany. All Rights Reserved.
+ * 
+ * This software is protected by copyright. Under no circumstances may any part of this file in any form be copied,
+ * printed, edited or otherwise distributed, be stored in a retrieval system, or be translated into another language
+ * without the written permission of iTAC Software AG.
+ */
+ // created 23.11.2018 08:09:59
+using System;
+using System.Collections.Generic;
+namespace com.itac.oib.monitoring.contracts.data
+{
+   // source: assembly 3.2.0.152
+   // source: assembly ASM.AS.OIB.Monitoring.Proxy
+   public class UsedTypeMapper
+   {
+
+      // map asm enum value to itac enum value
+      public static UsedType get(Asm.As.Oib.Monitoring.Proxy.Business.Types.UsedType usedType)
+      {
+         int intValue = (int)usedType;
+         return (UsedType)intValue;
+      }
+
+      // map itac enum value to ASM enum value
+      public static Asm.As.Oib.Monitoring.Proxy.Business.Types.UsedType get(UsedType usedType)
+      {
+         int intValue = (int)usedType;
+         return (Asm.As.Oib.Monitoring.Proxy.Business.Types.UsedType)intValue;
+      }
+   }
+}