diff --git a/org.eclipse.osbp.autowireHelper/src/org/eclipse/osbp/autowirehelper/AutowireHelper.xtend b/org.eclipse.osbp.autowireHelper/src/org/eclipse/osbp/autowirehelper/AutowireHelper.xtend
index cd3d71a..18a4b51 100644
--- a/org.eclipse.osbp.autowireHelper/src/org/eclipse/osbp/autowirehelper/AutowireHelper.xtend
+++ b/org.eclipse.osbp.autowireHelper/src/org/eclipse/osbp/autowirehelper/AutowireHelper.xtend
@@ -98,6 +98,7 @@
 import org.eclipse.xtext.util.IAcceptor
 import org.eclipse.xtext.util.concurrent.IUnitOfWork
 import org.eclipse.osbp.runtime.common.layouting.IPropertyConstants
+import org.eclipse.xtext.common.types.JvmField
 
 @SuppressWarnings("restriction")
 class AutowireHelper implements IAutowireDelegate {
@@ -239,7 +240,7 @@
 	def createSuspectStructure(Map<String, OperationInfo> opInfoMap, JvmDeclaredType dtoType, boolean mobile,
 		YTypedCompoundSuspect parentSuspect) {
 
-		opInfoMap.values.filter[!(it.databaseInfo)].forEach [
+		opInfoMap.values.filter[it.visible].forEach [
 			var JvmType type = null
 			try {
 				type = getter.returnType.type
@@ -252,12 +253,12 @@
 				properties.addAll(dtoType.toProperties(it.field.declaringType.qualifiedName + "." + it.name))
 			}
 
-			if (type.boolean && !it.isDirtyMark) {
+			if (type.boolean) {
 				if(mobile) type.createMobileSwitch(it) else suspect = type.createCheckbox(it)
 			} else if (type.numberWithDigits) {
 				suspect = type.createDecimalField(it)
 				if (dtoType.isAttribute(it.name, "NumberToUomo")) {
-					suspect.tags += "NumberToUomo"
+					suspect.tags += ILayoutingStrategy.TAG__NUMBER_TO_UOMO
 				} else {
 					var dataType = dtoType.toDataType(it.name)
 					if (dataType !== null) {
@@ -273,46 +274,44 @@
 					fieldType.equalsIgnoreCase(IPropertyConstants.PROPERTY_SLIDER)
 				]) {
 					suspect = type.createSlider(it, properties)
-				} else if (!it.idOrUUID && !it.version && !it.dirtyMark) {
+				} else {
 					suspect = type.createNumberField(it)
 				}
 			} else if (type.string) {
 				val fieldType = properties.findFirst[it.key.equals(IPropertyConstants.PROPERTY_KEY__FIELD_TYPE)]?.value
 
-				if (!it.idOrUUID && !it.version && !it.dirtyMark) {
-					var functionTypingAPI = new FunctionTypingAPI()
-					val functionImagePicker = functionTypingAPI.functionImagePickerTypeName
-					if (it.isDomainKey || it.isDomainDescription ||
-						(!fieldType.nullOrEmpty && fieldType.equals(IPropertyConstants.PROPERTY_SUGGESTTEXT))) {
-						suspect = type.createSuggestTextField(it, opInfoMap)
-					} else if (properties.exists[key.toLowerCase.equals(IPropertyConstants.PROPERTY_BLOB)]) {
-						suspect = type.createBlopUploadComponent(it)
-					} else if (!fieldType.nullOrEmpty && fieldType.equals(IPropertyConstants.PROPERTY_RICH_TEXT)) {
-						suspect = type.createRichTextField(it)
-					} else if (!fieldType.nullOrEmpty && fieldType.equals(IPropertyConstants.PROPERTY_MASKED_TEXT)) {
-						val mask = properties.findFirst[it.key.equals(IPropertyConstants.PROPERTY_MASK)]?.value
-						suspect = type.createMaskedTextField(it, mask)
-					} else if (!fieldType.nullOrEmpty && fieldType.equals(IPropertyConstants.PROPERTY_PASSWORD)) {
-						suspect = type.createPasswordField(it)
-					} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_TEXTAREA)]) {
-						suspect = type.createTextAreaField(it)
-					} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_ORGANIZATION)]) {
-						suspect = type.createOrganizationComboBox(it)
-					} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_PERSPECTIVE)]) {
-						suspect = type.createPerspectiveComboBox(it)
-					} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_PRINTSERVICE)]) {
-						suspect = type.createPrintServiceComboBox(it)
-					} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_I18N)]) {
-						suspect = type.createI18nComboBox(it)
-					} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_THEME)]) {
-						suspect = type.createThemeComboBox(it)
-					} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_MODEL)]) {
-						suspect = type.createModelComboBox(it)
-					} else if (properties.exists[key.equalsIgnoreCase(functionImagePicker)]) {
-						suspect = type.createIconComboBox(it)
-					} else {
-						suspect = type.createTextField(it)
-					}
+				var functionTypingAPI = new FunctionTypingAPI()
+				val functionImagePicker = functionTypingAPI.functionImagePickerTypeName
+				if (it.isDomainKey || it.isDomainDescription ||
+					(!fieldType.nullOrEmpty && fieldType.equals(IPropertyConstants.PROPERTY_SUGGESTTEXT))) {
+					suspect = type.createSuggestTextField(it, opInfoMap)
+				} else if (properties.exists[key.toLowerCase.equals(IPropertyConstants.PROPERTY_BLOB)]) {
+					suspect = type.createBlopUploadComponent(it)
+				} else if (!fieldType.nullOrEmpty && fieldType.equals(IPropertyConstants.PROPERTY_RICH_TEXT)) {
+					suspect = type.createRichTextField(it)
+				} else if (!fieldType.nullOrEmpty && fieldType.equals(IPropertyConstants.PROPERTY_MASKED_TEXT)) {
+					val mask = properties.findFirst[it.key.equals(IPropertyConstants.PROPERTY_MASK)]?.value
+					suspect = type.createMaskedTextField(it, mask)
+				} else if (!fieldType.nullOrEmpty && fieldType.equals(IPropertyConstants.PROPERTY_PASSWORD)) {
+					suspect = type.createPasswordField(it)
+				} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_TEXTAREA)]) {
+					suspect = type.createTextAreaField(it)
+				} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_ORGANIZATION)]) {
+					suspect = type.createOrganizationComboBox(it)
+				} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_PERSPECTIVE)]) {
+					suspect = type.createPerspectiveComboBox(it)
+				} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_PRINTSERVICE)]) {
+					suspect = type.createPrintServiceComboBox(it)
+				} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_I18N)]) {
+					suspect = type.createI18nComboBox(it)
+				} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_THEME)]) {
+					suspect = type.createThemeComboBox(it)
+				} else if (properties.exists[key.equalsIgnoreCase(IPropertyConstants.PROPERTY_MODEL)]) {
+					suspect = type.createModelComboBox(it)
+				} else if (properties.exists[key.equalsIgnoreCase(functionImagePicker)]) {
+					suspect = type.createIconComboBox(it)
+				} else {
+					suspect = type.createTextField(it)
 				}
 			} else if (type.date) {
 				suspect = type.createDateField(it)
@@ -355,6 +354,10 @@
 			}
 		]
 	}
+	
+	def boolean visible(OperationInfo info) {
+		return !info.idOrUUID && !info.version && !info.dirtyMark && !info.hidden && !info.databaseInfo
+	}
 
 	def createAuthorizationVisibilityProcessor(YAuthorizationable element, OperationInfo info) {
 		if (info.field !== null) {
@@ -369,6 +372,10 @@
 	def YSuspect createDtoSuspect(JvmType type, OperationInfo info) {
 		val dtoSuspect = YECviewFactory.eINSTANCE.createYTypedCompoundSuspect
 		dtoSuspect.tags += ILayoutingStrategy.TAG__DTO
+		// place bean on extra tab if true
+		if(info.beanOnTab) {
+			dtoSuspect.tags += ILayoutingStrategy.TAG__BEANONTAB
+		}
 		if (type instanceof JvmDeclaredType) {
 			type.createSuspectStructure(false, dtoSuspect)
 		}
@@ -433,15 +440,15 @@
 			suspect.id = '''«uiLayout.generateId».«info.name»'''
 
 			if (info.readonly) {
-				suspect.tags += "readonly"
+				suspect.tags += ILayoutingStrategy.TAG__READONLY
 			}
 
 			if (info.isOnKanbanCard) {
-				suspect.tags += "onKanbanCard"
+				suspect.tags += ILayoutingStrategy.TAG__ONKANBANCARD
 			}
 
 			if (info.isUniqueEntry) {
-				suspect.tags += "unique"
+				suspect.tags += ILayoutingStrategy.TAG__UNIQUE
 				var splittedId = info.id.split(":")
 				if (splittedId.length > 1) {
 					var fqClassName = splittedId.get(0)
@@ -454,7 +461,7 @@
 			}
 
 			if (isValidationConstraint(info)) {
-				suspect.tags += "constraint"
+				suspect.tags += ILayoutingStrategy.TAG__CONSTRAINT
 				var splittedId = info.id.split(":")
 				if (splittedId.length > 1) {
 					var fqClassName = splittedId.get(0)
@@ -496,13 +503,12 @@
 		JvmType parentType) {
 		if (suspect !== null) {
 			suspect.id = '''«parentSuspect.id».«info.name»'''
-
 			if (info.readonly) {
-				suspect.tags += "readonly"
+				suspect.tags += ILayoutingStrategy.TAG__READONLY
 			}
 
 			if (isValidationConstraint(info)) {
-				suspect.tags += "constraint"
+				suspect.tags += ILayoutingStrategy.TAG__CONSTRAINT
 				var splittedId = info.id.split(":")
 				if (splittedId.length > 1) {
 					var fqClassName = splittedId.get(0)
@@ -792,7 +798,7 @@
 		suspect.type = computer.loadClass(uiLayout.eResource.resourceSet, type.qualifiedName)
 		suspect.typeQualifiedName = type.qualifiedName
 		if (info.readonly) {
-			suspect.tags += "readonly"
+			suspect.tags += ILayoutingStrategy.TAG__READONLY
 		}
 		suspect
 	}
@@ -803,7 +809,7 @@
 		suspect.type = typeof(String)
 		suspect.typeQualifiedName = typeof(String).name
 		if (info.readonly) {
-			suspect.tags += "readonly"
+			suspect.tags += ILayoutingStrategy.TAG__READONLY
 		}
 		suspect
 	}
@@ -814,7 +820,7 @@
 		suspect.type = typeof(String)
 		suspect.typeQualifiedName = typeof(String).name
 		if (info.readonly) {
-			suspect.tags += "readonly"
+			suspect.tags += ILayoutingStrategy.TAG__READONLY
 		}
 		suspect
 	}
@@ -825,7 +831,7 @@
 		suspect.type = typeof(String)
 		suspect.typeQualifiedName = typeof(String).name
 		if (info.readonly) {
-			suspect.tags += "readonly"
+			suspect.tags += ILayoutingStrategy.TAG__READONLY
 		}
 		suspect
 	}
@@ -836,7 +842,7 @@
 		suspect.type = typeof(String)
 		suspect.typeQualifiedName = typeof(String).name
 		if (info.readonly) {
-			suspect.tags += "readonly"
+			suspect.tags += ILayoutingStrategy.TAG__READONLY
 		}
 		suspect
 	}
@@ -847,7 +853,7 @@
 		suspect.type = typeof(String)
 		suspect.typeQualifiedName = typeof(String).name
 		if (info.readonly) {
-			suspect.tags += "readonly"
+			suspect.tags += ILayoutingStrategy.TAG__READONLY
 		}
 		suspect
 	}
@@ -858,7 +864,7 @@
 		suspect.type = typeof(String)
 		suspect.typeQualifiedName = typeof(String).name
 		if (info.readonly) {
-			suspect.tags += "readonly"
+			suspect.tags += ILayoutingStrategy.TAG__READONLY
 		}
 		suspect
 	}
@@ -870,7 +876,7 @@
 		suspect.typeQualifiedName = type.qualifiedName
 		suspect.id = '''«uiLayout.generateId».«info.name»'''
 		if (info.readonly) {
-			suspect.tags += "readonly"
+			suspect.tags += ILayoutingStrategy.TAG__READONLY
 		}
 		suspect
 	}
@@ -887,7 +893,11 @@
 			suspect.id = '''«uiLayout.generateId».«info.name»'''
 
 			if (info.readonly) {
-				suspect.tags += "readonly"
+				suspect.tags += ILayoutingStrategy.TAG__READONLY
+			}
+
+			if (info.sideKick) {
+				suspect.tags += ILayoutingStrategy.TAG__SIDEKICK
 			}
 
 			if (info.hasAnnotation(FilterDepth)) {
@@ -934,7 +944,7 @@
 			val propMap = castedType.toFieldProperties
 			val opInfoMap = OperationExtensions.getOperationInfos(castedType)
 			val sortedOpInfoMap = createSortedOpInfoMapForCollections(opInfoMap)
-			sortedOpInfoMap.values.filter[!(it.databaseInfo) && !(it.idOrUUID) && !(it.version) && !(it.dirtyMark)].
+			sortedOpInfoMap.values.filter[it.visible].
 				forEach [
 					var JvmType detailType = it.getter.returnType.type
 					var YColumnInfo columnInfo = null
@@ -965,15 +975,23 @@
 						columnInfo.setYColumnInfoProperties(propList)
 					}
 					if (columnInfo !== null) {
-
 						// TODO (JCD): Simple name instead of FQN till solution of ticket - #581
 						columnInfo.labelI18nKey = columnInfo.name
+						// Setting source type for column permission checks
+						columnInfo.sourceType = computer.loadClass(uiLayout.eResource.resourceSet, it.field.sourceType)
 						suspect.columns += columnInfo
 					}
 				]
 		}
 		suspect
 	}
+	
+	def String getSourceType(JvmField field) {
+		if (field.eContainer instanceof JvmGenericType){
+			return (field.eContainer as JvmGenericType).identifier
+		}
+		return ""
+	}
 
 	/** 
 	 * Creates a proxy object 
diff --git a/org.eclipse.osbp.autowireHelper/xtend-gen/org/eclipse/osbp/autowirehelper/AutowireHelper.java b/org.eclipse.osbp.autowireHelper/xtend-gen/org/eclipse/osbp/autowirehelper/AutowireHelper.java
index 8617016..0e334b7 100644
--- a/org.eclipse.osbp.autowireHelper/xtend-gen/org/eclipse/osbp/autowirehelper/AutowireHelper.java
+++ b/org.eclipse.osbp.autowireHelper/xtend-gen/org/eclipse/osbp/autowirehelper/AutowireHelper.java
@@ -2,10 +2,10 @@
  * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * 
  *  All rights reserved. This program and the accompanying materials
- *  are made available under the terms of the Eclipse Public License 2.0 
+ *  are made available under the terms of the Eclipse Public License 2.0
  *  which accompanies this distribution, and is available at
  *  https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  *  SPDX-License-Identifier: EPL-2.0
  * 
  *  Contributors:
@@ -404,8 +404,7 @@
   
   public void createSuspectStructure(final Map<String, OperationExtensions.OperationInfo> opInfoMap, final JvmDeclaredType dtoType, final boolean mobile, final YTypedCompoundSuspect parentSuspect) {
     final Function1<OperationExtensions.OperationInfo, Boolean> _function = (OperationExtensions.OperationInfo it) -> {
-      boolean _isDatabaseInfo = it.isDatabaseInfo();
-      return Boolean.valueOf((!_isDatabaseInfo));
+      return Boolean.valueOf(this.visible(it));
     };
     final Consumer<OperationExtensions.OperationInfo> _function_1 = (OperationExtensions.OperationInfo it) -> {
       JvmType type = null;
@@ -430,7 +429,8 @@
         String _plus_1 = (_plus + _name);
         properties.addAll(this._autowireUtil.toProperties(dtoType, _plus_1));
       }
-      if ((this._typeHelper.isBoolean(type) && (!it.isDirtyMark()))) {
+      boolean _isBoolean = this._typeHelper.isBoolean(type);
+      if (_isBoolean) {
         if (mobile) {
           this.createMobileSwitch(type, it);
         } else {
@@ -443,7 +443,7 @@
           boolean _isAttribute = this._autowireUtil.isAttribute(dtoType, it.getName(), "NumberToUomo");
           if (_isAttribute) {
             EList<String> _tags = suspect.getTags();
-            _tags.add("NumberToUomo");
+            _tags.add(ILayoutingStrategy.TAG__NUMBER_TO_UOMO);
           } else {
             LDataType dataType = this._autowireUtil.toDataType(dtoType, it.getName());
             if ((dataType != null)) {
@@ -471,9 +471,7 @@
             })))) {
               suspect = this.createSlider(type, it, properties);
             } else {
-              if ((((!it.isIdOrUUID()) && (!it.isVersion())) && (!it.isDirtyMark()))) {
-                suspect = this.createNumberField(type, it);
-              }
+              suspect = this.createNumberField(type, it);
             }
           } else {
             boolean _isString = this._typeHelper.isString(type);
@@ -487,95 +485,93 @@
                 _value_1=_findFirst_1.value;
               }
               final String fieldType_1 = _value_1;
-              if ((((!it.isIdOrUUID()) && (!it.isVersion())) && (!it.isDirtyMark()))) {
-                FunctionTypingAPI functionTypingAPI = new FunctionTypingAPI();
-                final String functionImagePicker = functionTypingAPI.getFunctionImagePickerTypeName();
-                if (((this.isDomainKey(it) || this.isDomainDescription(it)) || ((!StringExtensions.isNullOrEmpty(fieldType_1)) && fieldType_1.equals(IPropertyConstants.PROPERTY_SUGGESTTEXT)))) {
-                  suspect = this.createSuggestTextField(type, it, opInfoMap);
+              FunctionTypingAPI functionTypingAPI = new FunctionTypingAPI();
+              final String functionImagePicker = functionTypingAPI.getFunctionImagePickerTypeName();
+              if (((this.isDomainKey(it) || this.isDomainDescription(it)) || ((!StringExtensions.isNullOrEmpty(fieldType_1)) && fieldType_1.equals(IPropertyConstants.PROPERTY_SUGGESTTEXT)))) {
+                suspect = this.createSuggestTextField(type, it, opInfoMap);
+              } else {
+                final Function1<AutowireUtil.Pair, Boolean> _function_4 = (AutowireUtil.Pair it_1) -> {
+                  return Boolean.valueOf(it_1.key.toLowerCase().equals(IPropertyConstants.PROPERTY_BLOB));
+                };
+                boolean _exists = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_4);
+                if (_exists) {
+                  suspect = this.createBlopUploadComponent(type, it);
                 } else {
-                  final Function1<AutowireUtil.Pair, Boolean> _function_4 = (AutowireUtil.Pair it_1) -> {
-                    return Boolean.valueOf(it_1.key.toLowerCase().equals(IPropertyConstants.PROPERTY_BLOB));
-                  };
-                  boolean _exists = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_4);
-                  if (_exists) {
-                    suspect = this.createBlopUploadComponent(type, it);
+                  if (((!StringExtensions.isNullOrEmpty(fieldType_1)) && fieldType_1.equals(IPropertyConstants.PROPERTY_RICH_TEXT))) {
+                    suspect = this.createRichTextField(type, it);
                   } else {
-                    if (((!StringExtensions.isNullOrEmpty(fieldType_1)) && fieldType_1.equals(IPropertyConstants.PROPERTY_RICH_TEXT))) {
-                      suspect = this.createRichTextField(type, it);
+                    if (((!StringExtensions.isNullOrEmpty(fieldType_1)) && fieldType_1.equals(IPropertyConstants.PROPERTY_MASKED_TEXT))) {
+                      final Function1<AutowireUtil.Pair, Boolean> _function_5 = (AutowireUtil.Pair it_1) -> {
+                        return Boolean.valueOf(it_1.key.equals(IPropertyConstants.PROPERTY_MASK));
+                      };
+                      AutowireUtil.Pair _findFirst_2 = IterableExtensions.<AutowireUtil.Pair>findFirst(properties, _function_5);
+                      String _value_2 = null;
+                      if (_findFirst_2!=null) {
+                        _value_2=_findFirst_2.value;
+                      }
+                      final String mask = _value_2;
+                      suspect = this.createMaskedTextField(type, it, mask);
                     } else {
-                      if (((!StringExtensions.isNullOrEmpty(fieldType_1)) && fieldType_1.equals(IPropertyConstants.PROPERTY_MASKED_TEXT))) {
-                        final Function1<AutowireUtil.Pair, Boolean> _function_5 = (AutowireUtil.Pair it_1) -> {
-                          return Boolean.valueOf(it_1.key.equals(IPropertyConstants.PROPERTY_MASK));
-                        };
-                        AutowireUtil.Pair _findFirst_2 = IterableExtensions.<AutowireUtil.Pair>findFirst(properties, _function_5);
-                        String _value_2 = null;
-                        if (_findFirst_2!=null) {
-                          _value_2=_findFirst_2.value;
-                        }
-                        final String mask = _value_2;
-                        suspect = this.createMaskedTextField(type, it, mask);
+                      if (((!StringExtensions.isNullOrEmpty(fieldType_1)) && fieldType_1.equals(IPropertyConstants.PROPERTY_PASSWORD))) {
+                        suspect = this.createPasswordField(type, it);
                       } else {
-                        if (((!StringExtensions.isNullOrEmpty(fieldType_1)) && fieldType_1.equals(IPropertyConstants.PROPERTY_PASSWORD))) {
-                          suspect = this.createPasswordField(type, it);
+                        final Function1<AutowireUtil.Pair, Boolean> _function_6 = (AutowireUtil.Pair it_1) -> {
+                          return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_TEXTAREA));
+                        };
+                        boolean _exists_1 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_6);
+                        if (_exists_1) {
+                          suspect = this.createTextAreaField(type, it);
                         } else {
-                          final Function1<AutowireUtil.Pair, Boolean> _function_6 = (AutowireUtil.Pair it_1) -> {
-                            return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_TEXTAREA));
+                          final Function1<AutowireUtil.Pair, Boolean> _function_7 = (AutowireUtil.Pair it_1) -> {
+                            return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_ORGANIZATION));
                           };
-                          boolean _exists_1 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_6);
-                          if (_exists_1) {
-                            suspect = this.createTextAreaField(type, it);
+                          boolean _exists_2 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_7);
+                          if (_exists_2) {
+                            suspect = this.createOrganizationComboBox(type, it);
                           } else {
-                            final Function1<AutowireUtil.Pair, Boolean> _function_7 = (AutowireUtil.Pair it_1) -> {
-                              return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_ORGANIZATION));
+                            final Function1<AutowireUtil.Pair, Boolean> _function_8 = (AutowireUtil.Pair it_1) -> {
+                              return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_PERSPECTIVE));
                             };
-                            boolean _exists_2 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_7);
-                            if (_exists_2) {
-                              suspect = this.createOrganizationComboBox(type, it);
+                            boolean _exists_3 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_8);
+                            if (_exists_3) {
+                              suspect = this.createPerspectiveComboBox(type, it);
                             } else {
-                              final Function1<AutowireUtil.Pair, Boolean> _function_8 = (AutowireUtil.Pair it_1) -> {
-                                return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_PERSPECTIVE));
+                              final Function1<AutowireUtil.Pair, Boolean> _function_9 = (AutowireUtil.Pair it_1) -> {
+                                return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_PRINTSERVICE));
                               };
-                              boolean _exists_3 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_8);
-                              if (_exists_3) {
-                                suspect = this.createPerspectiveComboBox(type, it);
+                              boolean _exists_4 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_9);
+                              if (_exists_4) {
+                                suspect = this.createPrintServiceComboBox(type, it);
                               } else {
-                                final Function1<AutowireUtil.Pair, Boolean> _function_9 = (AutowireUtil.Pair it_1) -> {
-                                  return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_PRINTSERVICE));
+                                final Function1<AutowireUtil.Pair, Boolean> _function_10 = (AutowireUtil.Pair it_1) -> {
+                                  return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_I18N));
                                 };
-                                boolean _exists_4 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_9);
-                                if (_exists_4) {
-                                  suspect = this.createPrintServiceComboBox(type, it);
+                                boolean _exists_5 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_10);
+                                if (_exists_5) {
+                                  suspect = this.createI18nComboBox(type, it);
                                 } else {
-                                  final Function1<AutowireUtil.Pair, Boolean> _function_10 = (AutowireUtil.Pair it_1) -> {
-                                    return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_I18N));
+                                  final Function1<AutowireUtil.Pair, Boolean> _function_11 = (AutowireUtil.Pair it_1) -> {
+                                    return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_THEME));
                                   };
-                                  boolean _exists_5 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_10);
-                                  if (_exists_5) {
-                                    suspect = this.createI18nComboBox(type, it);
+                                  boolean _exists_6 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_11);
+                                  if (_exists_6) {
+                                    suspect = this.createThemeComboBox(type, it);
                                   } else {
-                                    final Function1<AutowireUtil.Pair, Boolean> _function_11 = (AutowireUtil.Pair it_1) -> {
-                                      return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_THEME));
+                                    final Function1<AutowireUtil.Pair, Boolean> _function_12 = (AutowireUtil.Pair it_1) -> {
+                                      return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_MODEL));
                                     };
-                                    boolean _exists_6 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_11);
-                                    if (_exists_6) {
-                                      suspect = this.createThemeComboBox(type, it);
+                                    boolean _exists_7 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_12);
+                                    if (_exists_7) {
+                                      suspect = this.createModelComboBox(type, it);
                                     } else {
-                                      final Function1<AutowireUtil.Pair, Boolean> _function_12 = (AutowireUtil.Pair it_1) -> {
-                                        return Boolean.valueOf(it_1.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_MODEL));
+                                      final Function1<AutowireUtil.Pair, Boolean> _function_13 = (AutowireUtil.Pair it_1) -> {
+                                        return Boolean.valueOf(it_1.key.equalsIgnoreCase(functionImagePicker));
                                       };
-                                      boolean _exists_7 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_12);
-                                      if (_exists_7) {
-                                        suspect = this.createModelComboBox(type, it);
+                                      boolean _exists_8 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_13);
+                                      if (_exists_8) {
+                                        suspect = this.createIconComboBox(type, it);
                                       } else {
-                                        final Function1<AutowireUtil.Pair, Boolean> _function_13 = (AutowireUtil.Pair it_1) -> {
-                                          return Boolean.valueOf(it_1.key.equalsIgnoreCase(functionImagePicker));
-                                        };
-                                        boolean _exists_8 = IterableExtensions.<AutowireUtil.Pair>exists(properties, _function_13);
-                                        if (_exists_8) {
-                                          suspect = this.createIconComboBox(type, it);
-                                        } else {
-                                          suspect = this.createTextField(type, it);
-                                        }
+                                        suspect = this.createTextField(type, it);
                                       }
                                     }
                                   }
@@ -669,6 +665,10 @@
     IterableExtensions.<OperationExtensions.OperationInfo>filter(opInfoMap.values(), _function).forEach(_function_1);
   }
   
+  public boolean visible(final OperationExtensions.OperationInfo info) {
+    return (((((!info.isIdOrUUID()) && (!info.isVersion())) && (!info.isDirtyMark())) && (!info.isHidden())) && (!info.isDatabaseInfo()));
+  }
+  
   public void createAuthorizationVisibilityProcessor(final YAuthorizationable element, final OperationExtensions.OperationInfo info) {
     JvmField _field = info.getField();
     boolean _tripleNotEquals = (_field != null);
@@ -686,6 +686,11 @@
     final YTypedCompoundSuspect dtoSuspect = YECviewFactory.eINSTANCE.createYTypedCompoundSuspect();
     EList<String> _tags = dtoSuspect.getTags();
     _tags.add(ILayoutingStrategy.TAG__DTO);
+    boolean _beanOnTab = info.beanOnTab();
+    if (_beanOnTab) {
+      EList<String> _tags_1 = dtoSuspect.getTags();
+      _tags_1.add(ILayoutingStrategy.TAG__BEANONTAB);
+    }
     if ((type instanceof JvmDeclaredType)) {
       this.createSuspectStructure(((JvmDeclaredType)type), false, dtoSuspect);
     }
@@ -740,17 +745,17 @@
       boolean _isReadonly = info.isReadonly();
       if (_isReadonly) {
         EList<String> _tags = suspect.getTags();
-        _tags.add("readonly");
+        _tags.add(ILayoutingStrategy.TAG__READONLY);
       }
       boolean _isOnKanbanCard = this.isOnKanbanCard(info);
       if (_isOnKanbanCard) {
         EList<String> _tags_1 = suspect.getTags();
-        _tags_1.add("onKanbanCard");
+        _tags_1.add(ILayoutingStrategy.TAG__ONKANBANCARD);
       }
       boolean _isUniqueEntry = this.isUniqueEntry(info);
       if (_isUniqueEntry) {
         EList<String> _tags_2 = suspect.getTags();
-        _tags_2.add("unique");
+        _tags_2.add(ILayoutingStrategy.TAG__UNIQUE);
         String[] splittedId = info.getId().split(":");
         int _length = splittedId.length;
         boolean _greaterThan = (_length > 1);
@@ -764,7 +769,7 @@
       boolean _isValidationConstraint = this.isValidationConstraint(info);
       if (_isValidationConstraint) {
         EList<String> _tags_3 = suspect.getTags();
-        _tags_3.add("constraint");
+        _tags_3.add(ILayoutingStrategy.TAG__CONSTRAINT);
         String[] splittedId_1 = info.getId().split(":");
         int _length_1 = splittedId_1.length;
         boolean _greaterThan_1 = (_length_1 > 1);
@@ -821,12 +826,12 @@
       boolean _isReadonly = info.isReadonly();
       if (_isReadonly) {
         EList<String> _tags = suspect.getTags();
-        _tags.add("readonly");
+        _tags.add(ILayoutingStrategy.TAG__READONLY);
       }
       boolean _isValidationConstraint = this.isValidationConstraint(info);
       if (_isValidationConstraint) {
         EList<String> _tags_1 = suspect.getTags();
-        _tags_1.add("constraint");
+        _tags_1.add(ILayoutingStrategy.TAG__CONSTRAINT);
         String[] splittedId = info.getId().split(":");
         int _length = splittedId.length;
         boolean _greaterThan = (_length > 1);
@@ -1164,7 +1169,7 @@
       boolean _isReadonly = info.isReadonly();
       if (_isReadonly) {
         EList<String> _tags_1 = suspect.getTags();
-        _tags_1.add("readonly");
+        _tags_1.add(ILayoutingStrategy.TAG__READONLY);
       }
       _xblockexpression = suspect;
     }
@@ -1182,7 +1187,7 @@
       boolean _isReadonly = info.isReadonly();
       if (_isReadonly) {
         EList<String> _tags_1 = suspect.getTags();
-        _tags_1.add("readonly");
+        _tags_1.add(ILayoutingStrategy.TAG__READONLY);
       }
       _xblockexpression = suspect;
     }
@@ -1200,7 +1205,7 @@
       boolean _isReadonly = info.isReadonly();
       if (_isReadonly) {
         EList<String> _tags_1 = suspect.getTags();
-        _tags_1.add("readonly");
+        _tags_1.add(ILayoutingStrategy.TAG__READONLY);
       }
       _xblockexpression = suspect;
     }
@@ -1218,7 +1223,7 @@
       boolean _isReadonly = info.isReadonly();
       if (_isReadonly) {
         EList<String> _tags_1 = suspect.getTags();
-        _tags_1.add("readonly");
+        _tags_1.add(ILayoutingStrategy.TAG__READONLY);
       }
       _xblockexpression = suspect;
     }
@@ -1236,7 +1241,7 @@
       boolean _isReadonly = info.isReadonly();
       if (_isReadonly) {
         EList<String> _tags_1 = suspect.getTags();
-        _tags_1.add("readonly");
+        _tags_1.add(ILayoutingStrategy.TAG__READONLY);
       }
       _xblockexpression = suspect;
     }
@@ -1254,7 +1259,7 @@
       boolean _isReadonly = info.isReadonly();
       if (_isReadonly) {
         EList<String> _tags_1 = suspect.getTags();
-        _tags_1.add("readonly");
+        _tags_1.add(ILayoutingStrategy.TAG__READONLY);
       }
       _xblockexpression = suspect;
     }
@@ -1272,7 +1277,7 @@
       boolean _isReadonly = info.isReadonly();
       if (_isReadonly) {
         EList<String> _tags_1 = suspect.getTags();
-        _tags_1.add("readonly");
+        _tags_1.add(ILayoutingStrategy.TAG__READONLY);
       }
       _xblockexpression = suspect;
     }
@@ -1297,7 +1302,7 @@
       boolean _isReadonly = info.isReadonly();
       if (_isReadonly) {
         EList<String> _tags_1 = suspect.getTags();
-        _tags_1.add("readonly");
+        _tags_1.add(ILayoutingStrategy.TAG__READONLY);
       }
       _xblockexpression = suspect;
     }
@@ -1338,7 +1343,12 @@
         boolean _isReadonly = info.isReadonly();
         if (_isReadonly) {
           EList<String> _tags_1 = suspect.getTags();
-          _tags_1.add("readonly");
+          _tags_1.add(ILayoutingStrategy.TAG__READONLY);
+        }
+        boolean _sideKick = info.sideKick();
+        if (_sideKick) {
+          EList<String> _tags_2 = suspect.getTags();
+          _tags_2.add(ILayoutingStrategy.TAG__SIDEKICK);
         }
         boolean _hasAnnotation = info.hasAnnotation(FilterDepth.class);
         if (_hasAnnotation) {
@@ -1394,7 +1404,7 @@
         final Map<String, OperationExtensions.OperationInfo> opInfoMap = OperationExtensions.getOperationInfos(castedType);
         final LinkedHashMap<String, OperationExtensions.OperationInfo> sortedOpInfoMap = this.createSortedOpInfoMapForCollections(opInfoMap);
         final Function1<OperationExtensions.OperationInfo, Boolean> _function = (OperationExtensions.OperationInfo it) -> {
-          return Boolean.valueOf(((((!it.isDatabaseInfo()) && (!it.isIdOrUUID())) && (!it.isVersion())) && (!it.isDirtyMark())));
+          return Boolean.valueOf(this.visible(it));
         };
         final Consumer<OperationExtensions.OperationInfo> _function_1 = (OperationExtensions.OperationInfo it) -> {
           JvmType detailType = it.getGetter().getReturnType().getType();
@@ -1434,6 +1444,7 @@
           }
           if ((columnInfo != null)) {
             columnInfo.setLabelI18nKey(columnInfo.getName());
+            columnInfo.setSourceType(this.computer.loadClass(this.uiLayout.eResource().getResourceSet(), this.getSourceType(it.getField())));
             EList<YColumnInfo> _columns = suspect.getColumns();
             _columns.add(columnInfo);
           }
@@ -1445,6 +1456,15 @@
     return _xblockexpression;
   }
   
+  public String getSourceType(final JvmField field) {
+    EObject _eContainer = field.eContainer();
+    if ((_eContainer instanceof JvmGenericType)) {
+      EObject _eContainer_1 = field.eContainer();
+      return ((JvmGenericType) _eContainer_1).getIdentifier();
+    }
+    return "";
+  }
+  
   /**
    * Creates a proxy object
    */
diff --git a/org.eclipse.osbp.autowireHelper/xtend-gen/org/eclipse/osbp/autowirehelper/utils/AutowireUtil.java b/org.eclipse.osbp.autowireHelper/xtend-gen/org/eclipse/osbp/autowirehelper/utils/AutowireUtil.java
index b94aa12..aff31e3 100644
--- a/org.eclipse.osbp.autowireHelper/xtend-gen/org/eclipse/osbp/autowirehelper/utils/AutowireUtil.java
+++ b/org.eclipse.osbp.autowireHelper/xtend-gen/org/eclipse/osbp/autowirehelper/utils/AutowireUtil.java
@@ -2,10 +2,10 @@
  * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * 
  *  All rights reserved. This program and the accompanying materials
- *  are made available under the terms of the Eclipse Public License 2.0 
+ *  are made available under the terms of the Eclipse Public License 2.0
  *  which accompanies this distribution, and is available at
  *  https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  *  SPDX-License-Identifier: EPL-2.0
  * 
  *  Contributors:
