/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public virtual void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			// DiagramClassHasPresentationElements
			foreach (global::Tum.PDE.LanguageDSL.DiagramClassHasPresentationElements link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.DiagramClassHasPresentationElements>(this, global::Tum.PDE.LanguageDSL.DiagramClassHasPresentationElements.DiagramClassDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.PresentationElementClass);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.PresentationElementClass is DslEditorModeling::IModelMergeElements )
				{
					(link.PresentationElementClass as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public virtual void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			// DiagramClassViewReferencesDiagramClass
			foreach (global::Tum.PDE.LanguageDSL.DiagramClassViewReferencesDiagramClass link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.DiagramClassViewReferencesDiagramClass>(this, global::Tum.PDE.LanguageDSL.DiagramClassViewReferencesDiagramClass.DiagramClassViewDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewReferenceLink(protoLink);
			}
			// DiagramClassViewHasRootDiagramNodes
			foreach (global::Tum.PDE.LanguageDSL.DiagramClassViewHasRootDiagramNodes link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.DiagramClassViewHasRootDiagramNodes>(this, global::Tum.PDE.LanguageDSL.DiagramClassViewHasRootDiagramNodes.DiagramClassViewDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.RootDiagramNode);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.RootDiagramNode is DslEditorModeling::IModelMergeElements )
				{
					(link.RootDiagramNode as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public virtual void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			// ViewHasViewContexts
			foreach (global::Tum.PDE.LanguageDSL.ViewHasViewContexts link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.ViewHasViewContexts>(this, global::Tum.PDE.LanguageDSL.ViewHasViewContexts.ViewDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.BaseViewContext);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.BaseViewContext is DslEditorModeling::IModelMergeElements )
				{
					(link.BaseViewContext as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// ViewHasModelTree
			foreach (global::Tum.PDE.LanguageDSL.ViewHasModelTree link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.ViewHasModelTree>(this, global::Tum.PDE.LanguageDSL.ViewHasModelTree.ViewDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.ModelTree);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.ModelTree is DslEditorModeling::IModelMergeElements )
				{
					(link.ModelTree as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public override void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			base.ModelProcessMergeCopy(protoElement, protoGroup);
		
			// DomainEnumerationHasLiterals
			foreach (global::Tum.PDE.LanguageDSL.DomainEnumerationHasLiterals link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.DomainEnumerationHasLiterals>(this, global::Tum.PDE.LanguageDSL.DomainEnumerationHasLiterals.DomainEnumerationDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.EnumerationLiteral);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.EnumerationLiteral is DslEditorModeling::IModelMergeElements )
				{
					(link.EnumerationLiteral as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public override void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			base.ModelProcessMergeCopy(protoElement, protoGroup);
		
			// DomainRelationshipHasRoles
			foreach (global::Tum.PDE.LanguageDSL.DomainRelationshipHasRoles link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.DomainRelationshipHasRoles>(this, global::Tum.PDE.LanguageDSL.DomainRelationshipHasRoles.RelationshipDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.Role);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.Role is DslEditorModeling::IModelMergeElements )
				{
					(link.Role as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// DomainRelationshipReferencesSource
			foreach (global::Tum.PDE.LanguageDSL.DomainRelationshipReferencesSource link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.DomainRelationshipReferencesSource>(this, global::Tum.PDE.LanguageDSL.DomainRelationshipReferencesSource.RelationshipDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewReferenceLink(protoLink);
			}
			// DomainRelationshipReferencesTarget
			foreach (global::Tum.PDE.LanguageDSL.DomainRelationshipReferencesTarget link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.DomainRelationshipReferencesTarget>(this, global::Tum.PDE.LanguageDSL.DomainRelationshipReferencesTarget.RelationshipDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewReferenceLink(protoLink);
			}
			// DomainRelationshipReferencesBaseRelationship
			foreach (global::Tum.PDE.LanguageDSL.DomainRelationshipReferencesBaseRelationship link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.DomainRelationshipReferencesBaseRelationship>(this, global::Tum.PDE.LanguageDSL.DomainRelationshipReferencesBaseRelationship.DerivedRelationshipDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewReferenceLink(protoLink);
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public override void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			base.ModelProcessMergeCopy(protoElement, protoGroup);
		
			// LibraryModelContextHasClasses
			foreach (global::Tum.PDE.LanguageDSL.LibraryModelContextHasClasses link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.LibraryModelContextHasClasses>(this, global::Tum.PDE.LanguageDSL.LibraryModelContextHasClasses.LibraryModelContextDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.DomainClass);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.DomainClass is DslEditorModeling::IModelMergeElements )
				{
					(link.DomainClass as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// LibraryModelContextHasDiagramClasses
			foreach (global::Tum.PDE.LanguageDSL.LibraryModelContextHasDiagramClasses link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.LibraryModelContextHasDiagramClasses>(this, global::Tum.PDE.LanguageDSL.LibraryModelContextHasDiagramClasses.LibraryModelContextDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.DiagramClass);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.DiagramClass is DslEditorModeling::IModelMergeElements )
				{
					(link.DiagramClass as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// LibraryModelContextHasRelationships
			foreach (global::Tum.PDE.LanguageDSL.LibraryModelContextHasRelationships link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.LibraryModelContextHasRelationships>(this, global::Tum.PDE.LanguageDSL.LibraryModelContextHasRelationships.LibraryModelContextDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.DomainRelationship);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.DomainRelationship is DslEditorModeling::IModelMergeElements )
				{
					(link.DomainRelationship as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// LibraryModelContextHasSerializationModel
			foreach (global::Tum.PDE.LanguageDSL.LibraryModelContextHasSerializationModel link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.LibraryModelContextHasSerializationModel>(this, global::Tum.PDE.LanguageDSL.LibraryModelContextHasSerializationModel.LibraryModelContextDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.SerializationModel);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.SerializationModel is DslEditorModeling::IModelMergeElements )
				{
					(link.SerializationModel as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public virtual void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			// MetaModelLibraryHasImportedLibrary
			foreach (global::Tum.PDE.LanguageDSL.MetaModelLibraryHasImportedLibrary link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.MetaModelLibraryHasImportedLibrary>(this, global::Tum.PDE.LanguageDSL.MetaModelLibraryHasImportedLibrary.MetaModelLibraryDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.BaseMetaModel);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.BaseMetaModel is DslEditorModeling::IModelMergeElements )
				{
					(link.BaseMetaModel as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public override void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			base.ModelProcessMergeCopy(protoElement, protoGroup);
		
			// ViewContextHasDomainModelTreeView
			foreach (global::Tum.PDE.LanguageDSL.ViewContextHasDomainModelTreeView link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.ViewContextHasDomainModelTreeView>(this, global::Tum.PDE.LanguageDSL.ViewContextHasDomainModelTreeView.ViewContextDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.DomainModelTreeView);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.DomainModelTreeView is DslEditorModeling::IModelMergeElements )
				{
					(link.DomainModelTreeView as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// ViewContextHasDiagramView
			foreach (global::Tum.PDE.LanguageDSL.ViewContextHasDiagramView link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.ViewContextHasDiagramView>(this, global::Tum.PDE.LanguageDSL.ViewContextHasDiagramView.ViewContextDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.DiagramView);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.DiagramView is DslEditorModeling::IModelMergeElements )
				{
					(link.DiagramView as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// ViewContextReferencesModelContext
			foreach (global::Tum.PDE.LanguageDSL.ViewContextReferencesModelContext link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.ViewContextReferencesModelContext>(this, global::Tum.PDE.LanguageDSL.ViewContextReferencesModelContext.ViewContextDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewReferenceLink(protoLink);
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public override void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			base.ModelProcessMergeCopy(protoElement, protoGroup);
		
			// SerializedRelationshipHasSerializedDomainRoles
			foreach (global::Tum.PDE.LanguageDSL.SerializedRelationshipHasSerializedDomainRoles link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.SerializedRelationshipHasSerializedDomainRoles>(this, global::Tum.PDE.LanguageDSL.SerializedRelationshipHasSerializedDomainRoles.SerializedRelationshipDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.SerializedDomainRole);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.SerializedDomainRole is DslEditorModeling::IModelMergeElements )
				{
					(link.SerializedDomainRole as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public virtual void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			// FurtherInformationHasInformationItems
			foreach (global::Tum.PDE.LanguageDSL.FurtherInformationHasInformationItems link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.FurtherInformationHasInformationItems>(this, global::Tum.PDE.LanguageDSL.FurtherInformationHasInformationItems.FurtherInformationDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.InformationItem);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.InformationItem is DslEditorModeling::IModelMergeElements )
				{
					(link.InformationItem as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public override void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			base.ModelProcessMergeCopy(protoElement, protoGroup);
		
			// SerializationClassReferencesChildren
			foreach (global::Tum.PDE.LanguageDSL.SerializationClassReferencesChildren link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.SerializationClassReferencesChildren>(this, global::Tum.PDE.LanguageDSL.SerializationClassReferencesChildren.ParentDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewReferenceLink(protoLink);
			}
			// SerializationClassReferencesAttributes
			foreach (global::Tum.PDE.LanguageDSL.SerializationClassReferencesAttributes link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.SerializationClassReferencesAttributes>(this, global::Tum.PDE.LanguageDSL.SerializationClassReferencesAttributes.ElementDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewReferenceLink(protoLink);
			}
			// SerializationClassHasIdProperty
			foreach (global::Tum.PDE.LanguageDSL.SerializationClassHasIdProperty link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.SerializationClassHasIdProperty>(this, global::Tum.PDE.LanguageDSL.SerializationClassHasIdProperty.SerializationClassDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.SerializedIdProperty);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.SerializedIdProperty is DslEditorModeling::IModelMergeElements )
				{
					(link.SerializedIdProperty as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// SerializationClassHasProperties
			foreach (global::Tum.PDE.LanguageDSL.SerializationClassHasProperties link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.SerializationClassHasProperties>(this, global::Tum.PDE.LanguageDSL.SerializationClassHasProperties.SerializationClassDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.SerializedDomainProperty);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.SerializedDomainProperty is DslEditorModeling::IModelMergeElements )
				{
					(link.SerializedDomainProperty as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public override void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			base.ModelProcessMergeCopy(protoElement, protoGroup);
		
			// AttributedDomainElementHasProperties
			foreach (global::Tum.PDE.LanguageDSL.AttributedDomainElementHasProperties link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.AttributedDomainElementHasProperties>(this, global::Tum.PDE.LanguageDSL.AttributedDomainElementHasProperties.DomainElementDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.DomainProperty);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.DomainProperty is DslEditorModeling::IModelMergeElements )
				{
					(link.DomainProperty as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public virtual void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			// SerializationModelHasSerializedDomainModel
			foreach (global::Tum.PDE.LanguageDSL.SerializationModelHasSerializedDomainModel link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.SerializationModelHasSerializedDomainModel>(this, global::Tum.PDE.LanguageDSL.SerializationModelHasSerializedDomainModel.SerializationModelDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.SerializedDomainModel);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.SerializedDomainModel is DslEditorModeling::IModelMergeElements )
				{
					(link.SerializedDomainModel as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// SerializationModelHasChildren
			foreach (global::Tum.PDE.LanguageDSL.SerializationModelHasChildren link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.SerializationModelHasChildren>(this, global::Tum.PDE.LanguageDSL.SerializationModelHasChildren.SerializationModelDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.SerializationClass);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.SerializationClass is DslEditorModeling::IModelMergeElements )
				{
					(link.SerializationClass as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public override void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			base.ModelProcessMergeCopy(protoElement, protoGroup);
		
			// MetaModelHasDomainTypes
			foreach (global::Tum.PDE.LanguageDSL.MetaModelHasDomainTypes link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.MetaModelHasDomainTypes>(this, global::Tum.PDE.LanguageDSL.MetaModelHasDomainTypes.MetaModelDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.DomainType);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.DomainType is DslEditorModeling::IModelMergeElements )
				{
					(link.DomainType as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// MetaModelHasValidation
			foreach (global::Tum.PDE.LanguageDSL.MetaModelHasValidation link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.MetaModelHasValidation>(this, global::Tum.PDE.LanguageDSL.MetaModelHasValidation.MetaModelDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.Validation);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.Validation is DslEditorModeling::IModelMergeElements )
				{
					(link.Validation as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// MetaModelHasAdditionalInformation
			foreach (global::Tum.PDE.LanguageDSL.MetaModelHasAdditionalInformation link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.MetaModelHasAdditionalInformation>(this, global::Tum.PDE.LanguageDSL.MetaModelHasAdditionalInformation.MetaModelDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.AdditionalInformation);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.AdditionalInformation is DslEditorModeling::IModelMergeElements )
				{
					(link.AdditionalInformation as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// MetaModelHasMetaModelLibraries
			foreach (global::Tum.PDE.LanguageDSL.MetaModelHasMetaModelLibraries link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.MetaModelHasMetaModelLibraries>(this, global::Tum.PDE.LanguageDSL.MetaModelHasMetaModelLibraries.MetaModelDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.MetaModelLibrary);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.MetaModelLibrary is DslEditorModeling::IModelMergeElements )
				{
					(link.MetaModelLibrary as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// MetaModelHasView
			foreach (global::Tum.PDE.LanguageDSL.MetaModelHasView link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.MetaModelHasView>(this, global::Tum.PDE.LanguageDSL.MetaModelHasView.MetaModelDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.View);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.View is DslEditorModeling::IModelMergeElements )
				{
					(link.View as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// MetaModelHasModelContexts
			foreach (global::Tum.PDE.LanguageDSL.MetaModelHasModelContexts link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.MetaModelHasModelContexts>(this, global::Tum.PDE.LanguageDSL.MetaModelHasModelContexts.MetaModelDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.BaseModelContext);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.BaseModelContext is DslEditorModeling::IModelMergeElements )
				{
					(link.BaseModelContext as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
			// MetaModelHasPropertyGridEditors
			foreach (global::Tum.PDE.LanguageDSL.MetaModelHasPropertyGridEditors link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.MetaModelHasPropertyGridEditors>(this, global::Tum.PDE.LanguageDSL.MetaModelHasPropertyGridEditors.MetaModelDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.PropertyGridEditor);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.PropertyGridEditor is DslEditorModeling::IModelMergeElements )
				{
					(link.PropertyGridEditor as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}
		/// <summary>
		/// Processes a proto element representation of the element and adds required proto links. 
		/// This method is called on base classes from derived classes.
		/// 
		/// Hint: Properties do not need to be added in this method.
		/// </summary>
		/// <param name="protoElement">Proto element representation of the element.</param>
		/// <param name="protoGroup">Proto group the proto element belongs to.</param>
		public override void ModelProcessMergeCopy(DslEditorModeling::ModelProtoElement protoElement, DslEditorModeling::ModelProtoGroup protoGroup)
		{
			base.ModelProcessMergeCopy(protoElement, protoGroup);
		
			// EmbeddingDiagramNodeHasEmbeddingDiagramNodes
			foreach (global::Tum.PDE.LanguageDSL.EmbeddingDiagramNodeHasEmbeddingDiagramNodes link in DslModeling::DomainRoleInfo.GetElementLinks<global::Tum.PDE.LanguageDSL.EmbeddingDiagramNodeHasEmbeddingDiagramNodes>(this, global::Tum.PDE.LanguageDSL.EmbeddingDiagramNodeHasEmbeddingDiagramNodes.SourceEmbeddingDiagramNodeDomainRoleId))
			{
				DslEditorModeling::ModelProtoLink protoLink = new DslEditorModeling::ModelProtoLink(link);
				protoGroup.AddNewEmbeddingLink(protoLink);
				
				DslEditorModeling::ModelProtoElement protoElementRS = new DslEditorModeling::ModelProtoElement(link.TargetEmbeddingDiagramNode);
				protoGroup.AddNewElement(protoElementRS);
				
				// continue with target element
				if( link.TargetEmbeddingDiagramNode is DslEditorModeling::IModelMergeElements )
				{
					(link.TargetEmbeddingDiagramNode as DslEditorModeling::IModelMergeElements).ModelCreateMergeCopy(protoGroup);
				}
			}
		}