//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using DslModeling = global::Microsoft.VisualStudio.Modeling;
using DslDesign = global::Microsoft.VisualStudio.Modeling.Design;
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass PS_Model
	/// The root in which all other elements are embedded. Appears as a diagram.
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.PS_Model.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.PS_Model.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("ae0ee30b-2381-4418-b5f7-e10c830fa443")]
	public partial class PS_Model : DslModeling::ModelElement
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// PS_Model domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0xae0ee30b, 0x2381, 0x4418, 0xb5, 0xf7, 0xe1, 0x0c, 0x83, 0x0f, 0xa4, 0x43);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public PS_Model(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public PS_Model(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
		#region Machines opposite domain role accessor
		
		/// <summary>
		/// Gets a list of Machines.
		/// </summary>
		public virtual DslModeling::LinkedElementCollection<Machine> Machines
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return GetRoleCollection<DslModeling::LinkedElementCollection<Machine>, Machine>(global::MDC.ProductionSystem.ProductionSystemHasMachines.PS_ModelDomainRoleId);
			}
		}
		#endregion
		#region ConveyorBelts opposite domain role accessor
		
		/// <summary>
		/// Gets a list of ConveyorBelts.
		/// Description for MDC.ProductionSystem.PS_ModelHasConveyorBelts.PS_Model
		/// </summary>
		public virtual DslModeling::LinkedElementCollection<ConveyorBelt> ConveyorBelts
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return GetRoleCollection<DslModeling::LinkedElementCollection<ConveyorBelt>, ConveyorBelt>(global::MDC.ProductionSystem.PS_ModelHasConveyorBelts.PS_ModelDomainRoleId);
			}
		}
		#endregion
		#region Components opposite domain role accessor
		
		/// <summary>
		/// Gets a list of Components.
		/// Description for MDC.ProductionSystem.PS_ModelHasComponents.PS_Model
		/// </summary>
		public virtual DslModeling::LinkedElementCollection<Component> Components
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return GetRoleCollection<DslModeling::LinkedElementCollection<Component>, Component>(global::MDC.ProductionSystem.PS_ModelHasComponents.PS_ModelDomainRoleId);
			}
		}
		#endregion
		#region Operators opposite domain role accessor
		
		/// <summary>
		/// Gets a list of Operators.
		/// Description for MDC.ProductionSystem.PS_ModelHasOperators.PS_Model
		/// </summary>
		public virtual DslModeling::LinkedElementCollection<Operator> Operators
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return GetRoleCollection<DslModeling::LinkedElementCollection<Operator>, Operator>(global::MDC.ProductionSystem.PS_ModelHasOperators.PS_ModelDomainRoleId);
			}
		}
		#endregion
		#region ElementGroupPrototype Merge methods
		/// <summary>
		/// Returns a value indicating whether the source element represented by the
		/// specified root ProtoElement can be added to this element.
		/// </summary>
		/// <param name="rootElement">
		/// The root ProtoElement representing a source element.  This can be null, 
		/// in which case the ElementGroupPrototype does not contain an ProtoElements
		/// and the code should inspect the ElementGroupPrototype context information.
		/// </param>
		/// <param name="elementGroupPrototype">The ElementGroupPrototype that contains the root ProtoElement.</param>
		/// <returns>true if the source element represented by the ProtoElement can be added to this target element.</returns>
		protected override bool CanMerge(DslModeling::ProtoElementBase rootElement, DslModeling::ElementGroupPrototype elementGroupPrototype)
		{
			if ( elementGroupPrototype == null ) throw new global::System.ArgumentNullException("elementGroupPrototype");
			
			if (rootElement != null)
			{
				DslModeling::DomainClassInfo rootElementDomainInfo = this.Partition.DomainDataDirectory.GetDomainClass(rootElement.DomainClassId);
				
				if (rootElementDomainInfo.IsDerivedFrom(global::MDC.ProductionSystem.Component.DomainClassId)) 
				{
					return true;
				}
				
				if (rootElementDomainInfo.IsDerivedFrom(global::MDC.ProductionSystem.Operator.DomainClassId)) 
				{
					return true;
				}
				
				if (rootElementDomainInfo.IsDerivedFrom(global::MDC.ProductionSystem.Machine.DomainClassId)) 
				{
					return true;
				}
				
				if (rootElementDomainInfo.IsDerivedFrom(global::MDC.ProductionSystem.ConveyorBelt.DomainClassId)) 
				{
					return true;
				}
			}
			return base.CanMerge(rootElement, elementGroupPrototype);
		}
		
		/// <summary>
		/// Called by the Merge process to create a relationship between 
		/// this target element and the specified source element. 
		/// Typically, a parent-child relationship is established
		/// between the target element (the parent) and the source element 
		/// (the child), but any relationship can be established.
		/// </summary>
		/// <param name="sourceElement">The element that is to be related to this model element.</param>
		/// <param name="elementGroup">The group of source ModelElements that have been rehydrated into the target store.</param>
		/// <remarks>
		/// This method is overriden to create the relationship between the target element and the specified source element.
		/// The base method does nothing.
		/// </remarks>
		protected override void MergeRelate(DslModeling::ModelElement sourceElement, DslModeling::ElementGroup elementGroup)
		{
			// In general, sourceElement is allowed to be null, meaning that the elementGroup must be parsed for special cases.
			// However this is not supported in generated code.  Use double-deriving on this class and then override MergeRelate completely if you 
			// need to support this case.
			if ( sourceElement == null ) throw new global::System.ArgumentNullException("sourceElement");
		
				
			global::MDC.ProductionSystem.Component sourceComponent1 = sourceElement as global::MDC.ProductionSystem.Component;
			if (sourceComponent1 != null)
			{
				// Create link for path PS_ModelHasComponents.Components
				this.Components.Add(sourceComponent1);

				return;
			}
				
			global::MDC.ProductionSystem.Operator sourceOperator2 = sourceElement as global::MDC.ProductionSystem.Operator;
			if (sourceOperator2 != null)
			{
				// Create link for path PS_ModelHasOperators.Operators
				this.Operators.Add(sourceOperator2);

				return;
			}
				
			global::MDC.ProductionSystem.Machine sourceMachine3 = sourceElement as global::MDC.ProductionSystem.Machine;
			if (sourceMachine3 != null)
			{
				// Create link for path ProductionSystemHasMachines.Machines
				this.Machines.Add(sourceMachine3);

				return;
			}
				
			global::MDC.ProductionSystem.ConveyorBelt sourceConveyorBelt4 = sourceElement as global::MDC.ProductionSystem.ConveyorBelt;
			if (sourceConveyorBelt4 != null)
			{
				// Create link for path PS_ModelHasConveyorBelts.ConveyorBelts
				this.ConveyorBelts.Add(sourceConveyorBelt4);

				return;
			}
		
			// Sdk workaround to runtime bug #879350 (DSL: can't copy and paste a MEL that has a MEX). Avoid MergeRelate on ModelElementExtension
			// during a "Paste".
			if (sourceElement is DslModeling::ExtensionElement
				&& sourceElement.Store.TransactionManager.CurrentTransaction.TopLevelTransaction.Context.ContextInfo.ContainsKey("{9DAFD42A-DC0E-4d78-8C3F-8266B2CF8B33}"))
			{
				return;
			}
		
			// Fall through to base class if this class hasn't handled the merge.
			base.MergeRelate(sourceElement, elementGroup);
		}
		
		/// <summary>
		/// Performs operation opposite to MergeRelate - i.e. disconnects a given
		/// element from the current one (removes links created by MergeRelate).
		/// </summary>
		/// <param name="sourceElement">Element to be unmerged/disconnected.</param>
		[global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
		protected override void MergeDisconnect(DslModeling::ModelElement sourceElement)
		{
			if (sourceElement == null) throw new global::System.ArgumentNullException("sourceElement");
				
			global::MDC.ProductionSystem.Component sourceComponent1 = sourceElement as global::MDC.ProductionSystem.Component;
			if (sourceComponent1 != null)
			{
				// Delete link for path PS_ModelHasComponents.Components
				
				foreach (DslModeling::ElementLink link in global::MDC.ProductionSystem.PS_ModelHasComponents.GetLinks((global::MDC.ProductionSystem.PS_Model)this, sourceComponent1))
				{
					// Delete the link, but without possible delete propagation to the element since it's moving to a new location.
					link.Delete(global::MDC.ProductionSystem.PS_ModelHasComponents.PS_ModelDomainRoleId, global::MDC.ProductionSystem.PS_ModelHasComponents.ComponentDomainRoleId);
				}

				return;
			}
				
			global::MDC.ProductionSystem.Operator sourceOperator2 = sourceElement as global::MDC.ProductionSystem.Operator;
			if (sourceOperator2 != null)
			{
				// Delete link for path PS_ModelHasOperators.Operators
				
				foreach (DslModeling::ElementLink link in global::MDC.ProductionSystem.PS_ModelHasOperators.GetLinks((global::MDC.ProductionSystem.PS_Model)this, sourceOperator2))
				{
					// Delete the link, but without possible delete propagation to the element since it's moving to a new location.
					link.Delete(global::MDC.ProductionSystem.PS_ModelHasOperators.PS_ModelDomainRoleId, global::MDC.ProductionSystem.PS_ModelHasOperators.OperatorDomainRoleId);
				}

				return;
			}
				
			global::MDC.ProductionSystem.Machine sourceMachine3 = sourceElement as global::MDC.ProductionSystem.Machine;
			if (sourceMachine3 != null)
			{
				// Delete link for path ProductionSystemHasMachines.Machines
				
				foreach (DslModeling::ElementLink link in global::MDC.ProductionSystem.ProductionSystemHasMachines.GetLinks((global::MDC.ProductionSystem.PS_Model)this, sourceMachine3))
				{
					// Delete the link, but without possible delete propagation to the element since it's moving to a new location.
					link.Delete(global::MDC.ProductionSystem.ProductionSystemHasMachines.PS_ModelDomainRoleId, global::MDC.ProductionSystem.ProductionSystemHasMachines.ElementDomainRoleId);
				}

				return;
			}
				
			global::MDC.ProductionSystem.ConveyorBelt sourceConveyorBelt4 = sourceElement as global::MDC.ProductionSystem.ConveyorBelt;
			if (sourceConveyorBelt4 != null)
			{
				// Delete link for path PS_ModelHasConveyorBelts.ConveyorBelts
				
				foreach (DslModeling::ElementLink link in global::MDC.ProductionSystem.PS_ModelHasConveyorBelts.GetLinks((global::MDC.ProductionSystem.PS_Model)this, sourceConveyorBelt4))
				{
					// Delete the link, but without possible delete propagation to the element since it's moving to a new location.
					link.Delete(global::MDC.ProductionSystem.PS_ModelHasConveyorBelts.PS_ModelDomainRoleId, global::MDC.ProductionSystem.PS_ModelHasConveyorBelts.ConveyorBeltDomainRoleId);
				}

				return;
			}
			// Fall through to base class if this class hasn't handled the unmerge.
			base.MergeDisconnect(sourceElement);
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass Machine
	/// Elements embedded in the model. Appear as boxes on the diagram.
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.Machine.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.Machine.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("51de084f-1783-4393-bfd8-f36563e91f5a")]
	public partial class Machine : DslModeling::ModelElement
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// Machine domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x51de084f, 0x1783, 0x4393, 0xbf, 0xd8, 0xf3, 0x65, 0x63, 0xe9, 0x1f, 0x5a);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Machine(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Machine(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
		#region PS_Model opposite domain role accessor
		/// <summary>
		/// Gets or sets PS_Model.
		/// </summary>
		public virtual PS_Model PS_Model
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return DslModeling::DomainRoleInfo.GetLinkedElement(this, global::MDC.ProductionSystem.ProductionSystemHasMachines.ElementDomainRoleId) as PS_Model;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				DslModeling::DomainRoleInfo.SetLinkedElement(this, global::MDC.ProductionSystem.ProductionSystemHasMachines.ElementDomainRoleId, value);
			}
		}
		#endregion
		#region MA_CB_ConveyorBelts opposite domain role accessor
		
		/// <summary>
		/// Gets a list of MA_CB_ConveyorBelts.
		/// Description for
		/// MDC.ProductionSystem.MachineIsConnectedToConveyorBelt.MA_CB_Machine
		/// </summary>
		public virtual DslModeling::LinkedElementCollection<ConveyorBelt> MA_CB_ConveyorBelts
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return GetRoleCollection<DslModeling::LinkedElementCollection<ConveyorBelt>, ConveyorBelt>(global::MDC.ProductionSystem.MachineIsConnectedToConveyorBelt.MA_CB_MachineDomainRoleId);
			}
		}
		#endregion
		#region CB_MA_ConveyorBelts opposite domain role accessor
		
		/// <summary>
		/// Gets a list of CB_MA_ConveyorBelts.
		/// Description for
		/// MDC.ProductionSystem.ConveyorBeltsConnectedToMachines.CB_MA_Machine
		/// </summary>
		public virtual DslModeling::LinkedElementCollection<ConveyorBelt> CB_MA_ConveyorBelts
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return GetRoleCollection<DslModeling::LinkedElementCollection<ConveyorBelt>, ConveyorBelt>(global::MDC.ProductionSystem.ConveyorBeltsConnectedToMachines.CB_MA_MachineDomainRoleId);
			}
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass ConveyorBelt
	/// Description for MDC.ProductionSystem.ConveyorBelt
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.ConveyorBelt.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.ConveyorBelt.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("179e3680-a39f-42e2-94a3-72c1b93d96ef")]
	public partial class ConveyorBelt : DslModeling::ModelElement
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// ConveyorBelt domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x179e3680, 0xa39f, 0x42e2, 0x94, 0xa3, 0x72, 0xc1, 0xb9, 0x3d, 0x96, 0xef);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public ConveyorBelt(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public ConveyorBelt(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
		#region PS_Models opposite domain role accessor
		/// <summary>
		/// Gets or sets PS_Models.
		/// Description for MDC.ProductionSystem.PS_ModelHasConveyorBelts.ConveyorBelt
		/// </summary>
		public virtual PS_Model PS_Models
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return DslModeling::DomainRoleInfo.GetLinkedElement(this, global::MDC.ProductionSystem.PS_ModelHasConveyorBelts.ConveyorBeltDomainRoleId) as PS_Model;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				DslModeling::DomainRoleInfo.SetLinkedElement(this, global::MDC.ProductionSystem.PS_ModelHasConveyorBelts.ConveyorBeltDomainRoleId, value);
			}
		}
		#endregion
		#region MA_CB_Machines opposite domain role accessor
		/// <summary>
		/// Gets or sets MA_CB_Machines.
		/// Description for
		/// MDC.ProductionSystem.MachineIsConnectedToConveyorBelt.MA_CB_ConveyorBelt
		/// </summary>
		public virtual Machine MA_CB_Machines
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return DslModeling::DomainRoleInfo.GetLinkedElement(this, global::MDC.ProductionSystem.MachineIsConnectedToConveyorBelt.MA_CB_ConveyorBeltDomainRoleId) as Machine;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				DslModeling::DomainRoleInfo.SetLinkedElement(this, global::MDC.ProductionSystem.MachineIsConnectedToConveyorBelt.MA_CB_ConveyorBeltDomainRoleId, value);
			}
		}
		#endregion
		#region CB_MA_Machines opposite domain role accessor
		
		/// <summary>
		/// Gets a list of CB_MA_Machines.
		/// Description for
		/// MDC.ProductionSystem.ConveyorBeltsConnectedToMachines.CB_MA_ConveyorBelt
		/// </summary>
		public virtual DslModeling::LinkedElementCollection<Machine> CB_MA_Machines
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return GetRoleCollection<DslModeling::LinkedElementCollection<Machine>, Machine>(global::MDC.ProductionSystem.ConveyorBeltsConnectedToMachines.CB_MA_ConveyorBeltDomainRoleId);
			}
		}
		#endregion
		#region CB_CB_TargetConveyorBelts opposite domain role accessor
		/// <summary>
		/// Gets or sets CB_CB_TargetConveyorBelts.
		/// Description for
		/// MDC.ProductionSystem.ConveyorBeltsConnectedToConveyorBelt.CB_CB_SourceConveyorBelt
		/// </summary>
		public virtual ConveyorBelt CB_CB_TargetConveyorBelts
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return DslModeling::DomainRoleInfo.GetLinkedElement(this, global::MDC.ProductionSystem.ConveyorBeltsConnectedToConveyorBelt.CB_CB_SourceConveyorBeltDomainRoleId) as ConveyorBelt;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				DslModeling::DomainRoleInfo.SetLinkedElement(this, global::MDC.ProductionSystem.ConveyorBeltsConnectedToConveyorBelt.CB_CB_SourceConveyorBeltDomainRoleId, value);
			}
		}
		#endregion
		#region CB_CB_SourceConveyorBelts opposite domain role accessor
		
		/// <summary>
		/// Gets a list of CB_CB_SourceConveyorBelts.
		/// Description for
		/// MDC.ProductionSystem.ConveyorBeltsConnectedToConveyorBelt.CB_CB_TargetConveyorBelt
		/// </summary>
		public virtual DslModeling::LinkedElementCollection<ConveyorBelt> CB_CB_SourceConveyorBelts
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return GetRoleCollection<DslModeling::LinkedElementCollection<ConveyorBelt>, ConveyorBelt>(global::MDC.ProductionSystem.ConveyorBeltsConnectedToConveyorBelt.CB_CB_TargetConveyorBeltDomainRoleId);
			}
		}
		#endregion
		#region CO_CB_Components opposite domain role accessor
		/// <summary>
		/// Gets or sets CO_CB_Components.
		/// Description for
		/// MDC.ProductionSystem.ComponentIsOnConveyorBelt.CO_CB_ConveyorBelt
		/// </summary>
		public virtual Component CO_CB_Components
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return DslModeling::DomainRoleInfo.GetLinkedElement(this, global::MDC.ProductionSystem.ComponentIsOnConveyorBelt.CO_CB_ConveyorBeltDomainRoleId) as Component;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				DslModeling::DomainRoleInfo.SetLinkedElement(this, global::MDC.ProductionSystem.ComponentIsOnConveyorBelt.CO_CB_ConveyorBeltDomainRoleId, value);
			}
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass Component
	/// Description for MDC.ProductionSystem.Component
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.Component.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.Component.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("613728bc-b592-4f01-929c-47c6801a8d09")]
	public partial class Component : DslModeling::ModelElement
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// Component domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x613728bc, 0xb592, 0x4f01, 0x92, 0x9c, 0x47, 0xc6, 0x80, 0x1a, 0x8d, 0x09);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Component(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Component(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
		#region isBroken domain property code
		
		/// <summary>
		/// isBroken domain property Id.
		/// </summary>
		public static readonly global::System.Guid isBrokenDomainPropertyId = new global::System.Guid(0x2f339396, 0x4cfc, 0x47d8, 0x96, 0x34, 0x15, 0xe5, 0xac, 0x0a, 0xf4, 0x0e);
		
		/// <summary>
		/// Storage for isBroken
		/// </summary>
		private BrokenTypes isBrokenPropertyStorage = BrokenTypes.WORKING;
		
		/// <summary>
		/// Gets or sets the value of isBroken domain property.
		/// Description for MDC.ProductionSystem.Component.Is Broken
		/// </summary>
		[DslDesign::DisplayNameResource("MDC.ProductionSystem.Component/isBroken.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[DslDesign::DescriptionResource("MDC.ProductionSystem.Component/isBroken.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[global::System.ComponentModel.DefaultValue(BrokenTypes.WORKING)]
		[DslModeling::DomainObjectId("2f339396-4cfc-47d8-9634-15e5ac0af40e")]
		public BrokenTypes isBroken
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return isBrokenPropertyStorage;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				isBrokenPropertyHandler.Instance.SetValue(this, value);
			}
		}
		/// <summary>
		/// Value handler for the Component.isBroken domain property.
		/// </summary>
		internal sealed partial class isBrokenPropertyHandler : DslModeling::DomainPropertyValueHandler<Component, BrokenTypes>
		{
			private isBrokenPropertyHandler() { }
		
			/// <summary>
			/// Gets the singleton instance of the Component.isBroken domain property value handler.
			/// </summary>
			public static readonly isBrokenPropertyHandler Instance = new isBrokenPropertyHandler();
		
			/// <summary>
			/// Gets the Id of the Component.isBroken domain property.
			/// </summary>
			public sealed override global::System.Guid DomainPropertyId
			{
				[global::System.Diagnostics.DebuggerStepThrough]
				get
				{
					return isBrokenDomainPropertyId;
				}
			}
			
			/// <summary>
			/// Gets a strongly-typed value of the property on specified element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <returns>Property value.</returns>
			public override sealed BrokenTypes GetValue(Component element)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
				return element.isBrokenPropertyStorage;
			}
		
			/// <summary>
			/// Sets property value on an element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <param name="newValue">New property value.</param>
			public override sealed void SetValue(Component element, BrokenTypes newValue)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
		
				BrokenTypes oldValue = GetValue(element);
				if (newValue != oldValue)
				{
					ValueChanging(element, oldValue, newValue);
					element.isBrokenPropertyStorage = newValue;
					ValueChanged(element, oldValue, newValue);
				}
			}
		}
		
		#endregion
		#region PS_Models opposite domain role accessor
		/// <summary>
		/// Gets or sets PS_Models.
		/// Description for MDC.ProductionSystem.PS_ModelHasComponents.Component
		/// </summary>
		public virtual PS_Model PS_Models
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return DslModeling::DomainRoleInfo.GetLinkedElement(this, global::MDC.ProductionSystem.PS_ModelHasComponents.ComponentDomainRoleId) as PS_Model;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				DslModeling::DomainRoleInfo.SetLinkedElement(this, global::MDC.ProductionSystem.PS_ModelHasComponents.ComponentDomainRoleId, value);
			}
		}
		#endregion
		#region CO_CB_Conveyors opposite domain role accessor
		/// <summary>
		/// Gets or sets CO_CB_Conveyors.
		/// Description for MDC.ProductionSystem.ComponentIsOnConveyorBelt.CO_CB_Component
		/// </summary>
		public virtual ConveyorBelt CO_CB_Conveyors
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return DslModeling::DomainRoleInfo.GetLinkedElement(this, global::MDC.ProductionSystem.ComponentIsOnConveyorBelt.CO_CB_ComponentDomainRoleId) as ConveyorBelt;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				DslModeling::DomainRoleInfo.SetLinkedElement(this, global::MDC.ProductionSystem.ComponentIsOnConveyorBelt.CO_CB_ComponentDomainRoleId, value);
			}
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass Operator
	/// Description for MDC.ProductionSystem.Operator
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.Operator.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.Operator.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("056c014e-4ce2-45cb-9ff2-bfb061d55e43")]
	public partial class Operator : DslModeling::ModelElement
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// Operator domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x056c014e, 0x4ce2, 0x45cb, 0x9f, 0xf2, 0xbf, 0xb0, 0x61, 0xd5, 0x5e, 0x43);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Operator(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Operator(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
		#region Name domain property code
		
		/// <summary>
		/// Name domain property Id.
		/// </summary>
		public static readonly global::System.Guid NameDomainPropertyId = new global::System.Guid(0x70334c2d, 0xb96d, 0x4208, 0x9f, 0x41, 0xaa, 0x09, 0x5b, 0xb9, 0x42, 0xf2);
		
		/// <summary>
		/// Storage for Name
		/// </summary>
		private global::System.String namePropertyStorage = string.Empty;
		
		/// <summary>
		/// Gets or sets the value of Name domain property.
		/// Description for MDC.ProductionSystem.Operator.Name
		/// </summary>
		[DslDesign::DisplayNameResource("MDC.ProductionSystem.Operator/Name.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[DslDesign::DescriptionResource("MDC.ProductionSystem.Operator/Name.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[DslModeling::DomainObjectId("70334c2d-b96d-4208-9f41-aa095bb942f2")]
		public global::System.String Name
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return namePropertyStorage;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				NamePropertyHandler.Instance.SetValue(this, value);
			}
		}
		/// <summary>
		/// Value handler for the Operator.Name domain property.
		/// </summary>
		internal sealed partial class NamePropertyHandler : DslModeling::DomainPropertyValueHandler<Operator, global::System.String>
		{
			private NamePropertyHandler() { }
		
			/// <summary>
			/// Gets the singleton instance of the Operator.Name domain property value handler.
			/// </summary>
			public static readonly NamePropertyHandler Instance = new NamePropertyHandler();
		
			/// <summary>
			/// Gets the Id of the Operator.Name domain property.
			/// </summary>
			public sealed override global::System.Guid DomainPropertyId
			{
				[global::System.Diagnostics.DebuggerStepThrough]
				get
				{
					return NameDomainPropertyId;
				}
			}
			
			/// <summary>
			/// Gets a strongly-typed value of the property on specified element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <returns>Property value.</returns>
			public override sealed global::System.String GetValue(Operator element)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
				return element.namePropertyStorage;
			}
		
			/// <summary>
			/// Sets property value on an element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <param name="newValue">New property value.</param>
			public override sealed void SetValue(Operator element, global::System.String newValue)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
		
				global::System.String oldValue = GetValue(element);
				if (newValue != oldValue)
				{
					ValueChanging(element, oldValue, newValue);
					element.namePropertyStorage = newValue;
					ValueChanged(element, oldValue, newValue);
				}
			}
		}
		
		#endregion
		#region Stress domain property code
		
		/// <summary>
		/// Stress domain property Id.
		/// </summary>
		public static readonly global::System.Guid StressDomainPropertyId = new global::System.Guid(0x7d575472, 0x2aad, 0x44df, 0xa1, 0x22, 0x23, 0x08, 0x8d, 0x97, 0x69, 0xb1);
		
		/// <summary>
		/// Storage for Stress
		/// </summary>
		private global::System.UInt16 stressPropertyStorage;
		
		/// <summary>
		/// Gets or sets the value of Stress domain property.
		/// Description for MDC.ProductionSystem.Operator.Stress
		/// </summary>
		[DslDesign::DisplayNameResource("MDC.ProductionSystem.Operator/Stress.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[DslDesign::DescriptionResource("MDC.ProductionSystem.Operator/Stress.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[DslModeling::DomainObjectId("7d575472-2aad-44df-a122-23088d9769b1")]
		public global::System.UInt16 Stress
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return stressPropertyStorage;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				StressPropertyHandler.Instance.SetValue(this, value);
			}
		}
		/// <summary>
		/// Value handler for the Operator.Stress domain property.
		/// </summary>
		internal sealed partial class StressPropertyHandler : DslModeling::DomainPropertyValueHandler<Operator, global::System.UInt16>
		{
			private StressPropertyHandler() { }
		
			/// <summary>
			/// Gets the singleton instance of the Operator.Stress domain property value handler.
			/// </summary>
			public static readonly StressPropertyHandler Instance = new StressPropertyHandler();
		
			/// <summary>
			/// Gets the Id of the Operator.Stress domain property.
			/// </summary>
			public sealed override global::System.Guid DomainPropertyId
			{
				[global::System.Diagnostics.DebuggerStepThrough]
				get
				{
					return StressDomainPropertyId;
				}
			}
			
			/// <summary>
			/// Gets a strongly-typed value of the property on specified element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <returns>Property value.</returns>
			public override sealed global::System.UInt16 GetValue(Operator element)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
				return element.stressPropertyStorage;
			}
		
			/// <summary>
			/// Sets property value on an element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <param name="newValue">New property value.</param>
			public override sealed void SetValue(Operator element, global::System.UInt16 newValue)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
		
				global::System.UInt16 oldValue = GetValue(element);
				if (newValue != oldValue)
				{
					ValueChanging(element, oldValue, newValue);
					element.stressPropertyStorage = newValue;
					ValueChanged(element, oldValue, newValue);
				}
			}
		}
		
		#endregion
		#region PS_Models opposite domain role accessor
		/// <summary>
		/// Gets or sets PS_Models.
		/// Description for MDC.ProductionSystem.PS_ModelHasOperators.Operator
		/// </summary>
		public virtual PS_Model PS_Models
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return DslModeling::DomainRoleInfo.GetLinkedElement(this, global::MDC.ProductionSystem.PS_ModelHasOperators.OperatorDomainRoleId) as PS_Model;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				DslModeling::DomainRoleInfo.SetLinkedElement(this, global::MDC.ProductionSystem.PS_ModelHasOperators.OperatorDomainRoleId, value);
			}
		}
		#endregion
		#region OP_PU_ProcessingUnits opposite domain role accessor
		/// <summary>
		/// Gets or sets OP_PU_ProcessingUnits.
		/// Description for
		/// MDC.ProductionSystem.OperatorControlsProcessingUnits.OP_PU_Operator
		/// </summary>
		public virtual ProcessingUnit OP_PU_ProcessingUnits
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return DslModeling::DomainRoleInfo.GetLinkedElement(this, global::MDC.ProductionSystem.OperatorControlsProcessingUnits.OP_PU_OperatorDomainRoleId) as ProcessingUnit;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				DslModeling::DomainRoleInfo.SetLinkedElement(this, global::MDC.ProductionSystem.OperatorControlsProcessingUnits.OP_PU_OperatorDomainRoleId, value);
			}
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass ProducingUnit
	/// Description for MDC.ProductionSystem.ProducingUnit
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.ProducingUnit.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.ProducingUnit.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("d307b8c4-fb62-4ffc-90ab-bde9cad0decb")]
	public partial class ProducingUnit : Machine
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// ProducingUnit domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0xd307b8c4, 0xfb62, 0x4ffc, 0x90, 0xab, 0xbd, 0xe9, 0xca, 0xd0, 0xde, 0xcb);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public ProducingUnit(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public ProducingUnit(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
		#region Reliability domain property code
		
		/// <summary>
		/// Reliability domain property Id.
		/// </summary>
		public static readonly global::System.Guid ReliabilityDomainPropertyId = new global::System.Guid(0x7a9c6393, 0xa176, 0x453e, 0xb6, 0x28, 0xb4, 0xdb, 0x03, 0x13, 0x94, 0xa0);
		
		/// <summary>
		/// Storage for Reliability
		/// </summary>
		private global::System.UInt16 reliabilityPropertyStorage = 100;
		
		/// <summary>
		/// Gets or sets the value of Reliability domain property.
		/// Description for MDC.ProductionSystem.ProducingUnit.Reliability
		/// </summary>
		[DslDesign::DisplayNameResource("MDC.ProductionSystem.ProducingUnit/Reliability.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[DslDesign::DescriptionResource("MDC.ProductionSystem.ProducingUnit/Reliability.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[global::System.ComponentModel.DefaultValue(100)]
		[DslModeling::DomainObjectId("7a9c6393-a176-453e-b628-b4db031394a0")]
		public global::System.UInt16 Reliability
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return reliabilityPropertyStorage;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				ReliabilityPropertyHandler.Instance.SetValue(this, value);
			}
		}
		/// <summary>
		/// Value handler for the ProducingUnit.Reliability domain property.
		/// </summary>
		internal sealed partial class ReliabilityPropertyHandler : DslModeling::DomainPropertyValueHandler<ProducingUnit, global::System.UInt16>
		{
			private ReliabilityPropertyHandler() { }
		
			/// <summary>
			/// Gets the singleton instance of the ProducingUnit.Reliability domain property value handler.
			/// </summary>
			public static readonly ReliabilityPropertyHandler Instance = new ReliabilityPropertyHandler();
		
			/// <summary>
			/// Gets the Id of the ProducingUnit.Reliability domain property.
			/// </summary>
			public sealed override global::System.Guid DomainPropertyId
			{
				[global::System.Diagnostics.DebuggerStepThrough]
				get
				{
					return ReliabilityDomainPropertyId;
				}
			}
			
			/// <summary>
			/// Gets a strongly-typed value of the property on specified element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <returns>Property value.</returns>
			public override sealed global::System.UInt16 GetValue(ProducingUnit element)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
				return element.reliabilityPropertyStorage;
			}
		
			/// <summary>
			/// Sets property value on an element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <param name="newValue">New property value.</param>
			public override sealed void SetValue(ProducingUnit element, global::System.UInt16 newValue)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
		
				global::System.UInt16 oldValue = GetValue(element);
				if (newValue != oldValue)
				{
					ValueChanging(element, oldValue, newValue);
					element.reliabilityPropertyStorage = newValue;
					ValueChanged(element, oldValue, newValue);
				}
			}
		}
		
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass Garage
	/// Description for MDC.ProductionSystem.Garage
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.Garage.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.Garage.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("a1ec5f96-f913-4faf-8920-110502d60484")]
	public partial class Garage : Machine
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// Garage domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0xa1ec5f96, 0xf913, 0x4faf, 0x89, 0x20, 0x11, 0x05, 0x02, 0xd6, 0x04, 0x84);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Garage(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Garage(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass ProcessingUnit
	/// Description for MDC.ProductionSystem.ProcessingUnit
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.ProcessingUnit.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.ProcessingUnit.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("c7afd031-68bd-45fd-8db6-b0beceaee60b")]
	public partial class ProcessingUnit : ProducingUnit
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// ProcessingUnit domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0xc7afd031, 0x68bd, 0x45fd, 0x8d, 0xb6, 0xb0, 0xbe, 0xce, 0xae, 0xe6, 0x0b);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public ProcessingUnit(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public ProcessingUnit(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
		#region IdleTime domain property code
		
		/// <summary>
		/// IdleTime domain property Id.
		/// </summary>
		public static readonly global::System.Guid IdleTimeDomainPropertyId = new global::System.Guid(0x539b4efa, 0x9277, 0x4da9, 0x94, 0x5c, 0xac, 0xc0, 0x8c, 0x25, 0xfc, 0x8b);
		
		/// <summary>
		/// Storage for IdleTime
		/// </summary>
		private global::System.UInt16 idleTimePropertyStorage;
		
		/// <summary>
		/// Gets or sets the value of IdleTime domain property.
		/// Description for MDC.ProductionSystem.ProcessingUnit.Idle Time
		/// </summary>
		[DslDesign::DisplayNameResource("MDC.ProductionSystem.ProcessingUnit/IdleTime.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[DslDesign::DescriptionResource("MDC.ProductionSystem.ProcessingUnit/IdleTime.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[DslModeling::DomainObjectId("539b4efa-9277-4da9-945c-acc08c25fc8b")]
		public global::System.UInt16 IdleTime
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return idleTimePropertyStorage;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				IdleTimePropertyHandler.Instance.SetValue(this, value);
			}
		}
		/// <summary>
		/// Value handler for the ProcessingUnit.IdleTime domain property.
		/// </summary>
		internal sealed partial class IdleTimePropertyHandler : DslModeling::DomainPropertyValueHandler<ProcessingUnit, global::System.UInt16>
		{
			private IdleTimePropertyHandler() { }
		
			/// <summary>
			/// Gets the singleton instance of the ProcessingUnit.IdleTime domain property value handler.
			/// </summary>
			public static readonly IdleTimePropertyHandler Instance = new IdleTimePropertyHandler();
		
			/// <summary>
			/// Gets the Id of the ProcessingUnit.IdleTime domain property.
			/// </summary>
			public sealed override global::System.Guid DomainPropertyId
			{
				[global::System.Diagnostics.DebuggerStepThrough]
				get
				{
					return IdleTimeDomainPropertyId;
				}
			}
			
			/// <summary>
			/// Gets a strongly-typed value of the property on specified element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <returns>Property value.</returns>
			public override sealed global::System.UInt16 GetValue(ProcessingUnit element)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
				return element.idleTimePropertyStorage;
			}
		
			/// <summary>
			/// Sets property value on an element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <param name="newValue">New property value.</param>
			public override sealed void SetValue(ProcessingUnit element, global::System.UInt16 newValue)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
		
				global::System.UInt16 oldValue = GetValue(element);
				if (newValue != oldValue)
				{
					ValueChanging(element, oldValue, newValue);
					element.idleTimePropertyStorage = newValue;
					ValueChanged(element, oldValue, newValue);
				}
			}
		}
		
		#endregion
		#region OP_PU_Operators opposite domain role accessor
		/// <summary>
		/// Gets or sets OP_PU_Operators.
		/// Description for
		/// MDC.ProductionSystem.OperatorControlsProcessingUnits.OP_PU_ProcessingUnit
		/// </summary>
		public virtual Operator OP_PU_Operators
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return DslModeling::DomainRoleInfo.GetLinkedElement(this, global::MDC.ProductionSystem.OperatorControlsProcessingUnits.OP_PU_ProcessingUnitDomainRoleId) as Operator;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				DslModeling::DomainRoleInfo.SetLinkedElement(this, global::MDC.ProductionSystem.OperatorControlsProcessingUnits.OP_PU_ProcessingUnitDomainRoleId, value);
			}
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass Generator
	/// Description for MDC.ProductionSystem.Generator
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.Generator.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.Generator.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("dd48cfff-03d7-4f2e-bc6a-98460d068688")]
	public partial class Generator : ProducingUnit
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// Generator domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0xdd48cfff, 0x03d7, 0x4f2e, 0xbc, 0x6a, 0x98, 0x46, 0x0d, 0x06, 0x86, 0x88);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Generator(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Generator(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
		#region Output domain property code
		
		/// <summary>
		/// Output domain property Id.
		/// </summary>
		public static readonly global::System.Guid OutputDomainPropertyId = new global::System.Guid(0x68557cad, 0x6687, 0x47b7, 0xbd, 0x80, 0xa1, 0xa2, 0x21, 0x9d, 0xa5, 0xa1);
		
		/// <summary>
		/// Storage for Output
		/// </summary>
		private global::System.UInt16 outputPropertyStorage = 5;
		
		/// <summary>
		/// Gets or sets the value of Output domain property.
		/// Description for MDC.ProductionSystem.Generator.Output
		/// </summary>
		[DslDesign::DisplayNameResource("MDC.ProductionSystem.Generator/Output.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[DslDesign::DescriptionResource("MDC.ProductionSystem.Generator/Output.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[global::System.ComponentModel.DefaultValue(5)]
		[DslModeling::DomainObjectId("68557cad-6687-47b7-bd80-a1a2219da5a1")]
		public global::System.UInt16 Output
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return outputPropertyStorage;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				OutputPropertyHandler.Instance.SetValue(this, value);
			}
		}
		/// <summary>
		/// Value handler for the Generator.Output domain property.
		/// </summary>
		internal sealed partial class OutputPropertyHandler : DslModeling::DomainPropertyValueHandler<Generator, global::System.UInt16>
		{
			private OutputPropertyHandler() { }
		
			/// <summary>
			/// Gets the singleton instance of the Generator.Output domain property value handler.
			/// </summary>
			public static readonly OutputPropertyHandler Instance = new OutputPropertyHandler();
		
			/// <summary>
			/// Gets the Id of the Generator.Output domain property.
			/// </summary>
			public sealed override global::System.Guid DomainPropertyId
			{
				[global::System.Diagnostics.DebuggerStepThrough]
				get
				{
					return OutputDomainPropertyId;
				}
			}
			
			/// <summary>
			/// Gets a strongly-typed value of the property on specified element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <returns>Property value.</returns>
			public override sealed global::System.UInt16 GetValue(Generator element)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
				return element.outputPropertyStorage;
			}
		
			/// <summary>
			/// Sets property value on an element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <param name="newValue">New property value.</param>
			public override sealed void SetValue(Generator element, global::System.UInt16 newValue)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
		
				global::System.UInt16 oldValue = GetValue(element);
				if (newValue != oldValue)
				{
					ValueChanging(element, oldValue, newValue);
					element.outputPropertyStorage = newValue;
					ValueChanged(element, oldValue, newValue);
				}
			}
		}
		
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass Assembler
	/// Description for MDC.ProductionSystem.Assembler
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.Assembler.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.Assembler.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("3ae9f3d3-0a78-4325-ad9e-7d804340d9b5")]
	public partial class Assembler : ProcessingUnit
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// Assembler domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x3ae9f3d3, 0x0a78, 0x4325, 0xad, 0x9e, 0x7d, 0x80, 0x43, 0x40, 0xd9, 0xb5);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Assembler(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Assembler(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass RepairBay
	/// Description for MDC.ProductionSystem.RepairBay
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.RepairBay.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.RepairBay.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("0b9c5f62-306c-4e2e-a04b-8d1dc0d1d737")]
	public partial class RepairBay : ProcessingUnit
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// RepairBay domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x0b9c5f62, 0x306c, 0x4e2e, 0xa0, 0x4b, 0x8d, 0x1d, 0xc0, 0xd1, 0xd7, 0x37);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public RepairBay(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public RepairBay(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass QualityControl
	/// Description for MDC.ProductionSystem.QualityControl
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.QualityControl.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.QualityControl.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("0033539c-0ae4-40e1-872c-688d14566872")]
	public partial class QualityControl : ProcessingUnit
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// QualityControl domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x0033539c, 0x0ae4, 0x40e1, 0x87, 0x2c, 0x68, 0x8d, 0x14, 0x56, 0x68, 0x72);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public QualityControl(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public QualityControl(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass WheelGenerator
	/// Description for MDC.ProductionSystem.WheelGenerator
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.WheelGenerator.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.WheelGenerator.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("02238e35-8a1e-45af-a423-c750fad953d4")]
	public partial class WheelGenerator : Generator
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// WheelGenerator domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x02238e35, 0x8a1e, 0x45af, 0xa4, 0x23, 0xc7, 0x50, 0xfa, 0xd9, 0x53, 0xd4);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public WheelGenerator(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public WheelGenerator(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass TrackGenerator
	/// Description for MDC.ProductionSystem.TrackGenerator
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.TrackGenerator.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.TrackGenerator.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("69db0921-13d1-4f98-ac93-e6d875796bc3")]
	public partial class TrackGenerator : Generator
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// TrackGenerator domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x69db0921, 0x13d1, 0x4f98, 0xac, 0x93, 0xe6, 0xd8, 0x75, 0x79, 0x6b, 0xc3);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public TrackGenerator(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public TrackGenerator(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass BodyGenerator
	/// Description for MDC.ProductionSystem.BodyGenerator
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.BodyGenerator.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.BodyGenerator.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("f93c53e1-bddd-49cc-b1cf-bb2b67d16449")]
	public partial class BodyGenerator : Generator
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// BodyGenerator domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0xf93c53e1, 0xbddd, 0x49cc, 0xb1, 0xcf, 0xbb, 0x2b, 0x67, 0xd1, 0x64, 0x49);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public BodyGenerator(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public BodyGenerator(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass GunGenerator
	/// Description for MDC.ProductionSystem.GunGenerator
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.GunGenerator.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.GunGenerator.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("91eb85cb-162f-4166-810a-6c336257e67b")]
	public partial class GunGenerator : Generator
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// GunGenerator domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x91eb85cb, 0x162f, 0x4166, 0x81, 0x0a, 0x6c, 0x33, 0x62, 0x57, 0xe6, 0x7b);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public GunGenerator(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public GunGenerator(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass WaterGenerator
	/// Description for MDC.ProductionSystem.WaterGenerator
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.WaterGenerator.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.WaterGenerator.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("460a0d74-7057-4792-8d8c-52367e6e1275")]
	public partial class WaterGenerator : Generator
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// WaterGenerator domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x460a0d74, 0x7057, 0x4792, 0x8d, 0x8c, 0x52, 0x36, 0x7e, 0x6e, 0x12, 0x75);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public WaterGenerator(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public WaterGenerator(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass Wheel
	/// Description for MDC.ProductionSystem.Wheel
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.Wheel.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.Wheel.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("a9eed4e2-20b7-4942-bf43-46936337eceb")]
	public partial class Wheel : Component
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// Wheel domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0xa9eed4e2, 0x20b7, 0x4942, 0xbf, 0x43, 0x46, 0x93, 0x63, 0x37, 0xec, 0xeb);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Wheel(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Wheel(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass Track
	/// Description for MDC.ProductionSystem.Track
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.Track.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.Track.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("7ac2fccb-a56a-4f14-8011-c6d32dcefd87")]
	public partial class Track : Component
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// Track domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x7ac2fccb, 0xa56a, 0x4f14, 0x80, 0x11, 0xc6, 0xd3, 0x2d, 0xce, 0xfd, 0x87);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Track(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Track(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass Body
	/// Description for MDC.ProductionSystem.Body
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.Body.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.Body.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("8ee4366f-ab9c-46e4-b7ac-8012428759aa")]
	public partial class Body : Component
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// Body domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x8ee4366f, 0xab9c, 0x46e4, 0xb7, 0xac, 0x80, 0x12, 0x42, 0x87, 0x59, 0xaa);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Body(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Body(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
		#region Loadout domain property code
		
		/// <summary>
		/// Loadout domain property Id.
		/// </summary>
		public static readonly global::System.Guid LoadoutDomainPropertyId = new global::System.Guid(0x66815fb2, 0xe27e, 0x4729, 0x97, 0x13, 0xf4, 0x3e, 0xb3, 0x38, 0xa5, 0xa9);
		
		/// <summary>
		/// Storage for Loadout
		/// </summary>
		private LoadoutKind loadoutPropertyStorage = LoadoutKind.NoLoadout;
		
		/// <summary>
		/// Gets or sets the value of Loadout domain property.
		/// Description for MDC.ProductionSystem.Body.Loadout
		/// </summary>
		[DslDesign::DisplayNameResource("MDC.ProductionSystem.Body/Loadout.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[DslDesign::DescriptionResource("MDC.ProductionSystem.Body/Loadout.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
		[global::System.ComponentModel.DefaultValue(LoadoutKind.NoLoadout)]
		[DslModeling::DomainObjectId("66815fb2-e27e-4729-9713-f43eb338a5a9")]
		public LoadoutKind Loadout
		{
			[global::System.Diagnostics.DebuggerStepThrough]
			get
			{
				return loadoutPropertyStorage;
			}
			[global::System.Diagnostics.DebuggerStepThrough]
			set
			{
				LoadoutPropertyHandler.Instance.SetValue(this, value);
			}
		}
		/// <summary>
		/// Value handler for the Body.Loadout domain property.
		/// </summary>
		internal sealed partial class LoadoutPropertyHandler : DslModeling::DomainPropertyValueHandler<Body, LoadoutKind>
		{
			private LoadoutPropertyHandler() { }
		
			/// <summary>
			/// Gets the singleton instance of the Body.Loadout domain property value handler.
			/// </summary>
			public static readonly LoadoutPropertyHandler Instance = new LoadoutPropertyHandler();
		
			/// <summary>
			/// Gets the Id of the Body.Loadout domain property.
			/// </summary>
			public sealed override global::System.Guid DomainPropertyId
			{
				[global::System.Diagnostics.DebuggerStepThrough]
				get
				{
					return LoadoutDomainPropertyId;
				}
			}
			
			/// <summary>
			/// Gets a strongly-typed value of the property on specified element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <returns>Property value.</returns>
			public override sealed LoadoutKind GetValue(Body element)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
				return element.loadoutPropertyStorage;
			}
		
			/// <summary>
			/// Sets property value on an element.
			/// </summary>
			/// <param name="element">Element which owns the property.</param>
			/// <param name="newValue">New property value.</param>
			public override sealed void SetValue(Body element, LoadoutKind newValue)
			{
				if (element == null) throw new global::System.ArgumentNullException("element");
		
				LoadoutKind oldValue = GetValue(element);
				if (newValue != oldValue)
				{
					ValueChanging(element, oldValue, newValue);
					element.loadoutPropertyStorage = newValue;
					ValueChanged(element, oldValue, newValue);
				}
			}
		}
		
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass Gun
	/// Description for MDC.ProductionSystem.Gun
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.Gun.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.Gun.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("3e363d98-f3a9-4ca5-8d42-e1b87c4a1aff")]
	public partial class Gun : Component
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// Gun domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0x3e363d98, 0xf3a9, 0x4ca5, 0x8d, 0x42, 0xe1, 0xb8, 0x7c, 0x4a, 0x1a, 0xff);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Gun(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Gun(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
namespace MDC.ProductionSystem
{
	/// <summary>
	/// DomainClass Water
	/// Description for MDC.ProductionSystem.Water
	/// </summary>
	[DslDesign::DisplayNameResource("MDC.ProductionSystem.Water.DisplayName", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslDesign::DescriptionResource("MDC.ProductionSystem.Water.Description", typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel), "MDC.ProductionSystem.GeneratedCode.DomainModelResx")]
	[DslModeling::DomainModelOwner(typeof(global::MDC.ProductionSystem.ProductionSystemDomainModel))]
	[global::System.CLSCompliant(true)]
	[DslModeling::DomainObjectId("f548d289-8398-482c-b2bb-a07b92126a29")]
	public partial class Water : Component
	{
		#region Constructors, domain class Id
	
		/// <summary>
		/// Water domain class Id.
		/// </summary>
		public static readonly new global::System.Guid DomainClassId = new global::System.Guid(0xf548d289, 0x8398, 0x482c, 0xb2, 0xbb, 0xa0, 0x7b, 0x92, 0x12, 0x6a, 0x29);
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="store">Store where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Water(DslModeling::Store store, params DslModeling::PropertyAssignment[] propertyAssignments)
			: this(store != null ? store.DefaultPartitionForClass(DomainClassId) : null, propertyAssignments)
		{
		}
		
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="partition">Partition where new element is to be created.</param>
		/// <param name="propertyAssignments">List of domain property id/value pairs to set once the element is created.</param>
		public Water(DslModeling::Partition partition, params DslModeling::PropertyAssignment[] propertyAssignments)
			: base(partition, propertyAssignments)
		{
		}
		#endregion
	}
}
