diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/AbstractCustomerReport.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/AbstractCustomerReport.cs
index 9b05406b28eae60555165f4783721a62650973b1..8a890e00c50fc8c27eb8f16e29944092b7df82cb 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/AbstractCustomerReport.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/AbstractCustomerReport.cs
@@ -14,7 +14,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
 	public abstract class AbstractCustomerReport : IXMLCustomerReport
     {
 		protected readonly ICustomerInformationFileFactory _cifFactory;
-
+		protected XNamespace xsi = XNamespace.Get("http://www.w3.org/2001/XMLSchema-instance");
 		protected XElement Vehicle { get; set; }
 
 		protected AbstractCustomerReport(ICustomerInformationFileFactory cifFactory)
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFNinjectModule.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFNinjectModule.cs
index e3a6927d29a82849e8ac28b9b11354e393699207..ac4773051298c67d76d4ba09d46947e61f683379 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFNinjectModule.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFNinjectModule.cs
@@ -5,6 +5,7 @@ using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
 using Ninject.Activation;
+using Ninject.Extensions.ContextPreservation;
 using Ninject.Extensions.Factory;
 using Ninject.Extensions.NamedScope;
 using TUGraz.VectoCommon.InputData;
@@ -24,6 +25,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
 
 		public override void Load()
 		{
+			LoadModule<ContextPreservationModule>();
 			Bind<ICustomerInformationFileFactory>().ToFactory(() => new CombineArgumentsToNameInstanceProvider(
 				nameCombinationMethod, 6, 6, typeof(ICustomerInformationFileFactory).GetMethod(nameof(ICustomerInformationFileFactory
 					.GetCustomerReport)))).InSingletonScope();
@@ -32,7 +34,6 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
 				ToParams(VehicleCategoryHelper.Lorry, VectoSimulationJobType.ConventionalVehicle,
 					ArchitectureID.UNKNOWN, false, false, false)));
 
-
 			Bind<IXMLCustomerReport>().To<HEV_PxLorry_CIF>().Named(nameCombinationMethod(
 				ToParams(VehicleCategoryHelper.Lorry, VectoSimulationJobType.ParallelHybridVehicle,
 					ArchitectureID.UNKNOWN, false, false, false)));
@@ -51,49 +52,178 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
 
 			Bind<IXMLCustomerReport>().To<HEV_IEPC_Lorry_CIF>().Named(nameCombinationMethod(
 				ToParams(VehicleCategoryHelper.Lorry, VectoSimulationJobType.SerialHybridVehicle,
-					ArchitectureID.UNKNOWN, false,true, false)));
-
-
+					ArchitectureID.S_IEPC, false,true, false)));
+
+			Bind<IXMLCustomerReport>().To<PEV_E2_Lorry_CIF>().Named(nameCombinationMethod.Invoke(
+				ToParams(
+					VehicleCategoryHelper.Lorry,
+					VectoSimulationJobType.BatteryElectricVehicle,
+					ArchitectureID.E2,
+					false,
+					false,
+					false)));
+
+			Bind<IXMLCustomerReport>().To<PEV_E3_Lorry_CIF>().Named(nameCombinationMethod.Invoke(
+				ToParams(
+					VehicleCategoryHelper.Lorry,
+					VectoSimulationJobType.BatteryElectricVehicle,
+					ArchitectureID.E3,
+					false,
+					false,
+					false)));
+
+			Bind<IXMLCustomerReport>().To<PEV_E4_Lorry_CIF>().Named(nameCombinationMethod.Invoke(
+				ToParams(
+					VehicleCategoryHelper.Lorry,
+					VectoSimulationJobType.BatteryElectricVehicle,
+					ArchitectureID.E4,
+					false,
+					false,
+					false)));
+
+			Bind<IXMLCustomerReport>().To<PEV_IEPC_Lorry_CIF>().Named(nameCombinationMethod.Invoke(
+				ToParams(
+					VehicleCategoryHelper.Lorry,
+					VectoSimulationJobType.BatteryElectricVehicle,
+					ArchitectureID.E_IEPC,
+					false,
+					true,
+					false)));
+
+			Bind<IXMLCustomerReport>().To<PEV_IEPC_Lorry_CIF>().Named(nameCombinationMethod.Invoke(
+				ToParams(
+					VehicleCategoryHelper.Lorry,
+					VectoSimulationJobType.BatteryElectricVehicle,
+					ArchitectureID.E_IEPC,
+					false,
+					true,
+					false)));
+
+			Bind<IXMLCustomerReport>().To<PEV_IEPC_Lorry_CIF>().Named(nameCombinationMethod.Invoke(
+				ToParams(
+					VehicleCategoryHelper.Lorry,
+					VectoSimulationJobType.BatteryElectricVehicle,
+					ArchitectureID.E_IEPC,
+					false,
+					true,
+					false)));
+
+			Bind<IXMLCustomerReport>().To<Conventional_CompletedBusCIF>().Named(nameCombinationMethod.Invoke(
+				ToParams(VehicleCategoryHelper.CompletedBus,
+					VectoSimulationJobType.ConventionalVehicle,
+					ArchitectureID.UNKNOWN,
+					false,
+					false,
+					false)));
+
+			Bind<IXMLCustomerReport>().To<HEV_CompletedBusCIF>().Named(nameCombinationMethod.Invoke(
+				ToParams(VehicleCategoryHelper.CompletedBus,
+					VectoSimulationJobType.SerialHybridVehicle,
+					ArchitectureID.UNKNOWN,
+					false,
+					false,
+					false)));
+
+			Bind<IXMLCustomerReport>().To<HEV_CompletedBusCIF>().Named(nameCombinationMethod.Invoke(
+				ToParams(VehicleCategoryHelper.CompletedBus,
+					VectoSimulationJobType.ParallelHybridVehicle,
+					ArchitectureID.UNKNOWN,
+					false,
+					false,
+					false)));
+
+			Bind<IXMLCustomerReport>().To<PEV_CompletedBusCIF>().Named(nameCombinationMethod.Invoke(
+				ToParams(VehicleCategoryHelper.CompletedBus,
+					VectoSimulationJobType.BatteryElectricVehicle,
+					ArchitectureID.UNKNOWN,
+					false,
+					false,
+					false)));
 
 
 			#region VehicleTypes
-			Bind<IXmlTypeWriter>().To<CIFConventionalLorryVehicleWriter>()
+			Bind<IXmlTypeWriter>().To<CIFConventionalLorryVehicleWriter>().When(AccessedViaCIFFactory)
 				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetConventionalLorryVehicleType());
 
-			Bind<IXmlTypeWriter>().To<CIF_HEVPx_LorryVehicleWriter>()
+			Bind<IXmlTypeWriter>().To<CIF_HEVPx_LorryVehicleWriter>().When(AccessedViaCIFFactory)
 				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetHEV_PxLorryVehicleType());
 
+			Bind<IXmlTypeWriter>().To<CIF_HEV_S2_LorryVehicleWriter>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetHEV_S2_LorryVehicleType());
+
+			Bind<IXmlTypeWriter>().To<CIF_HEV_S3_LorryVehicleWriter>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetHEV_S3_LorryVehicleType());
+
+			Bind<IXmlTypeWriter>().To<CIF_HEV_S4_LorryVehicleWriter>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetHEV_S4_LorryVehicleType());
+
+			Bind<IXmlTypeWriter>().To<CIF_HEV_IEPC_S_LorryVehicleWriter>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetHEV_IEPC_LorryVehicleType());
+
+			Bind<IXmlTypeWriter>().To<CIF_PEV_E2_LorryVehicleWriter>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetPEV_E2_LorryVehicleType());
+
+			Bind<IXmlTypeWriter>().To<CIF_PEV_E3_LorryVehicleWriter>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetPEV_E3_LorryVehicleType());
+
+			Bind<IXmlTypeWriter>().To<CIF_PEV_E4_LorryVehicleWriter>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetPEV_E4_LorryVehicleType());
+
+			Bind<IXmlTypeWriter>().To<CIF_PEV_IEPC_LorryVehicleWriter>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetPEV_IEPC_LorryVehicleType());
+
+			Bind<IXmlTypeWriter>().To<CIF_ConventionalCompletedBusVehicleWriter>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetConventional_CompletedBusVehicleType());
+
 			#endregion
 			#region VehicleGroups
-			Bind<IMrfXmlGroup>().To<GeneralVehicleSequenceGroupCIF>()
+			Bind<IReportVehicleOutputGroup>().To<GeneralVehicleOutputSequenceGroupCif>().When(AccessedViaCIFFactory)
 				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetGeneralVehicleSequenceGroupWriter());
-			Bind<IMrfXmlGroup>().To<LorryGeneralVehicleSequenceGroupCIF>()
+			Bind<IReportOutputGroup>().To<LorryGeneralVehicleSequenceGroupCIF>().When(AccessedViaCIFFactory)
 				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetLorryGeneralVehicleSequenceGroupWriter());
-			Bind<IMrfXmlGroup>().To<ConventionalLorryVehicleSequenceGroupCIF>()
+			Bind<IReportOutputGroup>().To<ConventionalLorryVehicleSequenceGroupCIF>().When(AccessedViaCIFFactory)
 				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetConventionalLorryVehicleSequenceGroupWriter());
-
+			Bind<IReportOutputGroup>().To<HEV_LorryVehicleTypeGroupCIF>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetHEV_LorryVehicleTypeGroup());
+			Bind<IReportOutputGroup>().To<HEV_VehicleSequenceGroupWriter>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetHEV_VehicleSequenceGroupWriter());
+			Bind<IReportOutputGroup>().To<PEV_LorryVehicleTypeGroupCIF>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetPEV_LorryVehicleTypeGroup());
+			Bind<IReportOutputGroup>().To<PEV_VehicleSequenceGroupWriter>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetPEV_VehicleSequenceGroupWriter());
+
+			Bind<IReportOutputGroup>().To<CompletedBusVehicleTypeGroup>().When(AccessedViaCIFFactory)
+				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetCompletedBusVehicleTypeGroup());
 
 			#endregion
 			#region ComponentGroups
-			Bind<IMrfXmlGroup>().To<ComponentGroupWriters>()
+			Bind<IReportOutputGroup>().To<ComponentGroupWriters>().When(AccessedViaCIFFactory)
 				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetEngineGroup());
-			Bind<IMrfXmlGroup>().To<TransmissionGroup>()
+			Bind<IReportOutputGroup>().To<TransmissionGroup>().When(AccessedViaCIFFactory)
 				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetTransmissionGroup());
-			Bind<IMrfXmlGroup>().To<AxleWheelsGroup>()
+			Bind<IReportOutputGroup>().To<AxleWheelsGroup>().When(AccessedViaCIFFactory)
 				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetAxleWheelsGroup());
-			Bind<IMrfXmlGroup>().To<ElectricMachineGroup>()
+			Bind<IReportOutputGroup>().To<ElectricMachineGroup>().When(AccessedViaCIFFactory)
 				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetElectricMachineGroup());
-			Bind<IMrfXmlGroup>().To<REESSGroup>()
+			Bind<IReportOutputGroup>().To<REESSGroup>().When(AccessedViaCIFFactory)
 				.NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetREESSGroup());
+			Bind<IReportOutputGroup>().To<LorryAuxGroup>().When(AccessedViaCIFFactory).
+				NamedLikeFactoryMethod((ICustomerInformationFileFactory f) => f.GetLorryAuxGroup());
+
 			#endregion
 
-			
-			
 
-			
-		}
 
 
+		}
+
+		private bool AccessedViaCIFFactory(IRequest request)
+		{
+			if (request.ParentRequest == null) {
+				return false;
+			}
+			return typeof(ICustomerInformationFileFactory).IsAssignableFrom(request.ParentRequest.Service);
+		}
 
 		#endregion
 	}
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/AbstractCIFGroupWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/AbstractCIFGroupWriter.cs
index 93de2794f038cb93494fc90d10251265d27fee04..6e09eea23106306656c7bcacf0f124ca65981a9d 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/AbstractCIFGroupWriter.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/AbstractCIFGroupWriter.cs
@@ -11,7 +11,7 @@ using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.Manu
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter
 {
-    public abstract class AbstractCIFGroupWriter : IMrfXmlGroup
+    public abstract class AbstractCIFGroupWriter : IReportOutputGroup
     {
 		protected XNamespace _mrf = "urn:tugraz:ivt:VectoAPI:DeclarationOutput:v0.9";
 		protected XNamespace _cif = "urn:tugraz:ivt:VectoAPI:CustomerOutput:v0.9";
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/ComponentGroupWriters.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/ComponentGroupWriters.cs
index e7aef00cd1a8d10acc10cc53b3a25f37cb164563..9ea6914b67c79154f1fc709dca87d25793d28bf9 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/ComponentGroupWriters.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/ComponentGroupWriters.cs
@@ -124,9 +124,16 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
 		public override IList<XElement> GetElements(IDeclarationInputDataProvider inputData)
 		{
 			var result = new List<XElement>();
-			var totalRatedPropulsionPower =
-				inputData.JobInputData.Vehicle.Components.ElectricMachines.Entries
-					.Where(e => e.Position != PowertrainPosition.GEN).Sum((e => e.ElectricMachine.R85RatedPower));
+			Watt totalRatedPropulsionPower = null;
+			if (inputData.JobInputData.Vehicle.ArchitectureID == ArchitectureID.S_IEPC || inputData.JobInputData.Vehicle.ArchitectureID == ArchitectureID.E_IEPC) {
+				totalRatedPropulsionPower = inputData.JobInputData.Vehicle.Components.IEPC.R85RatedPower;
+			} else {
+				totalRatedPropulsionPower =
+					inputData.JobInputData.Vehicle.Components.ElectricMachines.Entries
+						.Where(e => e.Position != PowertrainPosition.GEN).Sum((e => e.ElectricMachine.R85RatedPower));
+			}
+			
+			
 			result.Add(new XElement(_cif + "TotalRatedPropulsionPower", totalRatedPropulsionPower.ValueAsUnit("kW")));
 			result.Add(new XElement(_cif + "MaxContinousPropulsionPower", "TODO"));
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/VehicleGroups.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/VehicleGroups.cs
index 9fd1359dd91af8d61475363cd5fb8036f8a1c018..3973d3e7beab0418cdb0871153ade5fb2da0973b 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/VehicleGroups.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/VehicleGroups.cs
@@ -12,15 +12,23 @@ using TUGraz.VectoCore.Utils;
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile.CustomerInformationFile_0_9.CIFWriter
 {
-    public class GeneralVehicleSequenceGroupCIF : AbstractCIFGroupWriter
+    public class GeneralVehicleOutputSequenceGroupCif : AbstractCIFGroupWriter, IReportVehicleOutputGroup
 	{
-		public GeneralVehicleSequenceGroupCIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+		public GeneralVehicleOutputSequenceGroupCif(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
 
 		#region Overrides of AbstractCIFGroupWriter
 
 		public override IList<XElement> GetElements(IDeclarationInputDataProvider inputData)
 		{
-			var vehicleData = inputData.JobInputData.Vehicle;
+			return GetElements(inputData.JobInputData.Vehicle);
+		}
+
+		#endregion
+
+		#region Implementation of IReportVehicleOutputGroup
+
+		public IList<XElement> GetElements(IVehicleDeclarationInputData vehicleData)
+		{
 			var result = new List<XElement>() {
 				new XElement(_cif + XMLNames.Vehicle_VIN, vehicleData.VIN),
 				new XElement(_cif + XMLNames.Vehicle_VehicleCategory, vehicleData.LegislativeClass.ToXMLFormat()),
@@ -91,7 +99,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
 		public override IList<XElement> GetElements(IDeclarationInputDataProvider inputData)
 		{
 			var result = new List<XElement>();
-			result.AddRange(_cifFactory.GetGeneralVehicleSequenceGroupWriter().GetElements(inputData));
+			result.AddRange(_cifFactory.GetGeneralVehicleSequenceGroupWriter().GetElements(inputData.JobInputData.Vehicle));
 			result.AddRange(_cifFactory.GetLorryGeneralVehicleSequenceGroupWriter().GetElements(inputData));
 			result.AddRange(_cifFactory.GetHEV_VehicleSequenceGroupWriter().GetElements(inputData));
 
@@ -100,6 +108,24 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
 
 		#endregion
 	}
+	public class PEV_LorryVehicleTypeGroupCIF : AbstractCIFGroupWriter
+	{
+		public PEV_LorryVehicleTypeGroupCIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCIFGroupWriter
+
+		public override IList<XElement> GetElements(IDeclarationInputDataProvider inputData)
+		{
+			var result = new List<XElement>();
+			result.AddRange(_cifFactory.GetGeneralVehicleSequenceGroupWriter().GetElements(inputData.JobInputData.Vehicle));
+			result.AddRange(_cifFactory.GetLorryGeneralVehicleSequenceGroupWriter().GetElements(inputData));
+			result.AddRange(_cifFactory.GetPEV_VehicleSequenceGroupWriter().GetElements(inputData));
+
+			return result;
+		}
+
+		#endregion
+	}
 
 
 	public class HEV_VehicleSequenceGroupWriter : AbstractCIFGroupWriter
@@ -125,4 +151,47 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
 
 		#endregion
 	}
+
+
+	public class PEV_VehicleSequenceGroupWriter : AbstractCIFGroupWriter
+	{
+		public PEV_VehicleSequenceGroupWriter(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCIFGroupWriter
+
+		public override IList<XElement> GetElements(IDeclarationInputDataProvider inputData)
+		{
+			var result = new List<XElement>();
+			var ovCc = inputData.JobInputData.Vehicle.OvcHev;
+			result.AddRange(new List<XElement>() {
+				new XElement(_cif + "PEVArchitecture", inputData.JobInputData.Vehicle.ArchitectureID.GetLabel()),
+				new XElement(_cif + "OffVehicleChargingCapability", ovCc)
+			});
+			if (ovCc)
+			{
+				result.Add(new XElement(_cif + "OffVehicleChargingMaxPower", inputData.JobInputData.Vehicle.MaxChargingPower.ValueAsUnit("kW")));
+			}
+			return result;
+		}
+
+		#endregion
+	}
+
+
+	public class CompletedBusVehicleTypeGroup : AbstractCIFGroupWriter
+	{
+		public CompletedBusVehicleTypeGroup(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCIFGroupWriter
+
+		public override IList<XElement> GetElements(IDeclarationInputDataProvider inputData)
+		{
+			var completedBusData = inputData as IMultistageBusInputDataProvider;
+			var result = new List<XElement>();
+			result.AddRange(_cifFactory.GetGeneralVehicleSequenceGroupWriter().GetElements(completedBusData.JobInputData.ConsolidateManufacturingStage.Vehicle));
+			return result;
+		}
+
+		#endregion
+	}
 }
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/VehicleWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/VehicleWriter.cs
index dd96f035d868bbb637591cc13a54cc38cb85dd35..7be6f98bab7c6f81dbbb10d4ed74b1d9e2a32b9d 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/VehicleWriter.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFWriter/VehicleWriter.cs
@@ -33,6 +33,25 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
 		public abstract XElement GetElement(IDeclarationInputDataProvider inputData);
 
 		#endregion
+
+
+		protected XElement GetRetarder(IDeclarationInputDataProvider inputData)
+		{
+			return new XElement(_cif + XMLNames.Component_Retarder,
+				inputData.JobInputData.Vehicle.Components.RetarderInputData.Type != RetarderType.None);
+		}
+
+		protected XElement GetAxleRatio(IDeclarationInputDataProvider inputData, bool optional = false)
+		{
+			if (!optional || (inputData.JobInputData.Vehicle.Components.AxleGearInputData != null)) {
+				return new XElement(_cif + XMLNames.Axlegear_Ratio,
+					inputData.JobInputData.Vehicle.Components.AxleGearInputData.Ratio.ToXMLFormat(2));
+			} else {
+				return null;
+			}
+			
+		}
+		
 	}
 
 
@@ -49,14 +68,14 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
 		public override XElement GetElement(IDeclarationInputDataProvider inputData)
 		{
 			return new XElement(_cif + XMLNames.Component_Vehicle,
-					_cifFactory.GetGeneralVehicleSequenceGroupWriter().GetElements(inputData),
+					_cifFactory.GetGeneralVehicleSequenceGroupWriter().GetElements(inputData.JobInputData.Vehicle),
 					_cifFactory.GetLorryGeneralVehicleSequenceGroupWriter().GetElements(inputData),
 					_cifFactory.GetConventionalLorryVehicleSequenceGroupWriter().GetElements(inputData),
 					_mrfFactory.GetConventionalADASType().GetXmlType(inputData.JobInputData.Vehicle.ADAS),
 					_cifFactory.GetEngineGroup().GetElements(inputData),
 					_cifFactory.GetTransmissionGroup().GetElements(inputData),
-					new XElement(_cif + XMLNames.Component_Retarder, inputData.JobInputData.Vehicle.Components.RetarderInputData.Type != RetarderType.None),
-					new XElement(_cif + XMLNames.Axlegear_Ratio, inputData.JobInputData.Vehicle.Components.AxleGearInputData.Ratio.ToXMLFormat(2)),
+					GetRetarder(inputData),
+					GetAxleRatio(inputData),
 					_cifFactory.GetAxleWheelsGroup().GetElements(inputData),
 					_cifFactory.GetLorryAuxGroup().GetElements(inputData)
 			);
@@ -90,5 +109,204 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
 		#endregion
 	}
 
+	public class CIF_HEV_S2_LorryVehicleWriter : VehicleWriter
+	{
+		public CIF_HEV_S2_LorryVehicleWriter(ICustomerInformationFileFactory cifFactory, IManufacturerReportFactory mrfFactory) : base(cifFactory, mrfFactory) { }
+
+		#region Overrides of VehicleWriter
+
+		public override XElement GetElement(IDeclarationInputDataProvider inputData)
+		{
+			return new XElement(_cif + XMLNames.Component_Vehicle,
+				_cifFactory.GetHEV_LorryVehicleTypeGroup().GetElements(inputData),
+				_mrfFactory.GetHEVADASType().GetXmlType(inputData.JobInputData.Vehicle.ADAS),
+				_cifFactory.GetEngineGroup().GetElements(inputData),
+				_cifFactory.GetTransmissionGroup().GetElements(inputData),
+				GetRetarder(inputData),
+				GetAxleRatio(inputData),
+				_cifFactory.GetAxleWheelsGroup().GetElements(inputData),
+				_cifFactory.GetElectricMachineGroup().GetElements(inputData),
+				_cifFactory.GetREESSGroup().GetElements(inputData),
+				_cifFactory.GetLorryAuxGroup().GetElements(inputData)
+			);
+		}
+
+		#endregion
+	}
+
+	public class CIF_HEV_S3_LorryVehicleWriter : VehicleWriter
+	{
+		public CIF_HEV_S3_LorryVehicleWriter(ICustomerInformationFileFactory cifFactory, IManufacturerReportFactory mrfFactory) : base(cifFactory, mrfFactory) { }
+
+		#region Overrides of VehicleWriter
+
+		public override XElement GetElement(IDeclarationInputDataProvider inputData)
+		{
+			return new XElement(_cif + XMLNames.Component_Vehicle,
+				_cifFactory.GetHEV_LorryVehicleTypeGroup().GetElements(inputData),
+				_mrfFactory.GetHEVADASType().GetXmlType(inputData.JobInputData.Vehicle.ADAS),
+				_cifFactory.GetEngineGroup().GetElements(inputData),
+				GetRetarder(inputData),
+				GetAxleRatio(inputData),
+				_cifFactory.GetAxleWheelsGroup().GetElements(inputData),
+				_cifFactory.GetElectricMachineGroup().GetElements(inputData),
+				_cifFactory.GetREESSGroup().GetElements(inputData),
+				_cifFactory.GetLorryAuxGroup().GetElements(inputData)
+			);
+		}
+
+		#endregion
+	}
+
+	public class CIF_HEV_S4_LorryVehicleWriter : VehicleWriter
+	{
+		public CIF_HEV_S4_LorryVehicleWriter(ICustomerInformationFileFactory cifFactory, IManufacturerReportFactory mrfFactory) : base(cifFactory, mrfFactory) { }
+
+		#region Overrides of VehicleWriter
+
+		public override XElement GetElement(IDeclarationInputDataProvider inputData)
+		{
+			return new XElement(_cif + XMLNames.Component_Vehicle,
+				_cifFactory.GetHEV_LorryVehicleTypeGroup().GetElements(inputData),
+				_mrfFactory.GetHEVADASType().GetXmlType(inputData.JobInputData.Vehicle.ADAS),
+				_cifFactory.GetEngineGroup().GetElements(inputData),
+				_cifFactory.GetAxleWheelsGroup().GetElements(inputData),
+				_cifFactory.GetElectricMachineGroup().GetElements(inputData),
+				_cifFactory.GetREESSGroup().GetElements(inputData),
+				_cifFactory.GetLorryAuxGroup().GetElements(inputData)
+			);
+		}
+
+		#endregion
+	}
+
+	public class CIF_HEV_IEPC_S_LorryVehicleWriter : VehicleWriter
+	{
+		public CIF_HEV_IEPC_S_LorryVehicleWriter(ICustomerInformationFileFactory cifFactory, IManufacturerReportFactory mrfFactory) : base(cifFactory, mrfFactory) { }
+
+		#region Overrides of VehicleWriter
+
+		public override XElement GetElement(IDeclarationInputDataProvider inputData)
+		{
+			return new XElement(_cif + XMLNames.Component_Vehicle,
+				_cifFactory.GetHEV_LorryVehicleTypeGroup().GetElements(inputData),
+				_mrfFactory.GetHEVADASType().GetXmlType(inputData.JobInputData.Vehicle.ADAS),
+				_cifFactory.GetEngineGroup().GetElements(inputData),
+				GetRetarder(inputData),
+				GetAxleRatio(inputData, true),
+				_cifFactory.GetAxleWheelsGroup().GetElements(inputData),
+				_cifFactory.GetElectricMachineGroup().GetElements(inputData),
+				_cifFactory.GetREESSGroup().GetElements(inputData),
+				_cifFactory.GetLorryAuxGroup().GetElements(inputData)
+			);
+		}
+
+		#endregion
+	}
+
+	public class CIF_PEV_E2_LorryVehicleWriter : VehicleWriter
+	{
+		public CIF_PEV_E2_LorryVehicleWriter(ICustomerInformationFileFactory cifFactory, IManufacturerReportFactory mrfFactory) : base(cifFactory, mrfFactory) { }
+
+		#region Overrides of VehicleWriter
+
+		public override XElement GetElement(IDeclarationInputDataProvider inputData)
+		{
+			return new XElement(_cif + XMLNames.Component_Vehicle,
+				_cifFactory.GetPEV_LorryVehicleTypeGroup().GetElements(inputData),
+				_mrfFactory.GetPEVADASType().GetXmlType(inputData.JobInputData.Vehicle.ADAS),
+				_cifFactory.GetTransmissionGroup().GetElements(inputData),
+				GetRetarder(inputData),
+				GetAxleRatio(inputData),
+				_cifFactory.GetAxleWheelsGroup().GetElements(inputData),
+				_cifFactory.GetElectricMachineGroup().GetElements(inputData),
+				_cifFactory.GetREESSGroup().GetElements(inputData),
+				_cifFactory.GetLorryAuxGroup().GetElements(inputData)
+			);
+		}
+
+		#endregion
+	}
+
+	public class CIF_PEV_E3_LorryVehicleWriter : VehicleWriter
+	{
+		public CIF_PEV_E3_LorryVehicleWriter(ICustomerInformationFileFactory cifFactory, IManufacturerReportFactory mrfFactory) : base(cifFactory, mrfFactory) { }
+
+		#region Overrides of VehicleWriter
+
+		public override XElement GetElement(IDeclarationInputDataProvider inputData)
+		{
+			return new XElement(_cif + XMLNames.Component_Vehicle,
+				_cifFactory.GetPEV_LorryVehicleTypeGroup().GetElements(inputData),
+				_mrfFactory.GetPEVADASType().GetXmlType(inputData.JobInputData.Vehicle.ADAS),
+				GetRetarder(inputData),
+				GetAxleRatio(inputData),
+				_cifFactory.GetAxleWheelsGroup().GetElements(inputData),
+				_cifFactory.GetElectricMachineGroup().GetElements(inputData),
+				_cifFactory.GetREESSGroup().GetElements(inputData),
+				_cifFactory.GetLorryAuxGroup().GetElements(inputData)
+			);
+		}
+
+		#endregion
+	}
+
+	public class CIF_PEV_E4_LorryVehicleWriter : VehicleWriter
+	{
+		public CIF_PEV_E4_LorryVehicleWriter(ICustomerInformationFileFactory cifFactory, IManufacturerReportFactory mrfFactory) : base(cifFactory, mrfFactory) { }
+
+		#region Overrides of VehicleWriter
+
+		public override XElement GetElement(IDeclarationInputDataProvider inputData)
+		{
+			return new XElement(_cif + XMLNames.Component_Vehicle,
+				_cifFactory.GetPEV_LorryVehicleTypeGroup().GetElements(inputData),
+				_mrfFactory.GetPEVADASType().GetXmlType(inputData.JobInputData.Vehicle.ADAS),
+				_cifFactory.GetAxleWheelsGroup().GetElements(inputData),
+				_cifFactory.GetElectricMachineGroup().GetElements(inputData),
+				_cifFactory.GetREESSGroup().GetElements(inputData),
+				_cifFactory.GetLorryAuxGroup().GetElements(inputData)
+			);
+		}
+
+		#endregion
+	}
+
+	public class CIF_PEV_IEPC_LorryVehicleWriter : VehicleWriter
+	{
+		public CIF_PEV_IEPC_LorryVehicleWriter(ICustomerInformationFileFactory cifFactory, IManufacturerReportFactory mrfFactory) : base(cifFactory, mrfFactory) { }
+
+		#region Overrides of VehicleWriter
+
+		public override XElement GetElement(IDeclarationInputDataProvider inputData)
+		{
+			return new XElement(_cif + XMLNames.Component_Vehicle,
+				_cifFactory.GetPEV_LorryVehicleTypeGroup().GetElements(inputData),
+				_mrfFactory.GetPEVADASType().GetXmlType(inputData.JobInputData.Vehicle.ADAS),
+				GetRetarder(inputData),
+				GetAxleRatio(inputData, true),
+				_cifFactory.GetAxleWheelsGroup().GetElements(inputData),
+				_cifFactory.GetElectricMachineGroup().GetElements(inputData),
+				_cifFactory.GetREESSGroup().GetElements(inputData),
+				_cifFactory.GetLorryAuxGroup().GetElements(inputData)
+			);
+		}
+
+		#endregion
+	}
+
+	public class CIF_ConventionalCompletedBusVehicleWriter : VehicleWriter
+	{
+		public CIF_ConventionalCompletedBusVehicleWriter(ICustomerInformationFileFactory cifFactory, IManufacturerReportFactory mrfFactory) : base(cifFactory, mrfFactory) { }
+
+		#region Overrides of VehicleWriter
+
+		public override XElement GetElement(IDeclarationInputDataProvider inputData)
+		{
+			return new XElement(_cif + XMLNames.Component_Vehicle,
+				_cifFactory.GetCompletedBusVehicleTypeGroup().GetElements(inputData));
+		}
 
+		#endregion
+	}
 }
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CustomerInformationFile/CustomerInformationFile.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CustomerInformationFile/CustomerInformationFile.cs
new file mode 100644
index 0000000000000000000000000000000000000000..bb9aaff2098b459fd4967113895503abba321875
--- /dev/null
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CustomerInformationFile/CustomerInformationFile.cs
@@ -0,0 +1,235 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReport;
+using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportXMLTypeWriter;
+
+namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile.CustomerInformationFile_0_9.CustomerInformationFile
+{
+    public abstract class CustomerInformationFile : AbstractCustomerReport
+    {
+        public static XNamespace Cif => XNamespace.Get("urn:tugraz:ivt:VectoAPI:CustomerOutput:v0.9");
+
+		protected void GenerateReport(string outputDataType)
+		{
+			Report = new XDocument(new XElement(Cif + "VectoOutput",
+				new XAttribute("xmlns", Cif),
+				new XAttribute(XNamespace.Xmlns + "xsi", xsi),
+				new XAttribute(XNamespace.Xmlns + "mrf", LorryManufacturerReportBase.Mrf),
+				new XAttribute(xsi + "type", $"{outputDataType}"),
+				Vehicle));
+			//;new XElement(Cif + "Results")));
+		}
+
+        protected CustomerInformationFile(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+	}
+    #region LorryCIF
+    public class ConventionalLorry_CIF : CustomerInformationFile
+	{
+		public ConventionalLorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCustomerReport
+
+		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+		{
+			Vehicle = _cifFactory.GetConventionalLorryVehicleType().GetElement(inputData);
+			GenerateReport("ConventionalLorryOutputType");
+		}
+
+		#endregion
+	}
+
+	public class HEV_PxLorry_CIF : CustomerInformationFile
+	{
+		public HEV_PxLorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCustomerReport
+
+		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+		{
+			var vehicle = _cifFactory.GetHEV_PxLorryVehicleType();
+			Vehicle = _cifFactory.GetHEV_PxLorryVehicleType().GetElement(inputData);
+			GenerateReport("HEV_Px_LorryOutputType");
+		}
+		#endregion
+	}
+
+	public class HEV_S2_Lorry_CIF : CustomerInformationFile
+	{
+		public HEV_S2_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCustomerReport
+
+		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+		{
+			Vehicle = _cifFactory.GetHEV_S2_LorryVehicleType().GetElement(inputData);
+			GenerateReport("HEV_S2_LorryVehicleType");
+		}
+
+		#endregion
+	}
+
+	public class HEV_S3_Lorry_CIF : CustomerInformationFile
+	{
+		public HEV_S3_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCustomerReport
+
+		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+		{
+			Vehicle = _cifFactory.GetHEV_S3_LorryVehicleType().GetElement(inputData);
+			GenerateReport("HEV_S3_LorryVehicleType");
+		}
+
+		#endregion
+	}
+
+	public class HEV_S4_Lorry_CIF : CustomerInformationFile
+	{
+		public HEV_S4_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCustomerReport
+
+		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+		{
+			Vehicle = _cifFactory.GetHEV_S4_LorryVehicleType().GetElement(inputData);
+			GenerateReport("HEV_S4_LorryVehicleType");
+		}
+
+		#endregion
+	}
+
+	public class HEV_IEPC_Lorry_CIF : CustomerInformationFile
+	{
+		public HEV_IEPC_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCustomerReport
+
+		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+		{
+			Vehicle = _cifFactory.GetHEV_IEPC_LorryVehicleType().GetElement(inputData);
+			GenerateReport("HEV_IEPC_S_LorryVehicleType");
+		}
+
+		#endregion
+	}
+
+	public class PEV_E2_Lorry_CIF : CustomerInformationFile
+	{
+		public PEV_E2_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCustomerReport
+
+		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+		{
+			Vehicle = _cifFactory.GetPEV_E2_LorryVehicleType().GetElement(inputData);
+			GenerateReport("PEV_E2_LorryVehicleType");
+		}
+
+		#endregion
+	}
+
+	public class PEV_E3_Lorry_CIF : CustomerInformationFile
+	{
+		public PEV_E3_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCustomerReport
+
+		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+		{
+			Vehicle = _cifFactory.GetPEV_E3_LorryVehicleType().GetElement(inputData);
+			GenerateReport("PEV_E3_LorryVehicleType");
+		}
+
+		#endregion
+	}
+
+	public class PEV_E4_Lorry_CIF : CustomerInformationFile
+	{
+		public PEV_E4_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCustomerReport
+
+		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+		{
+			Vehicle = _cifFactory.GetPEV_E4_LorryVehicleType().GetElement(inputData);
+			GenerateReport("PEV_E4_LorryVehicleType");
+		}
+
+		#endregion
+	}
+
+	public class PEV_IEPC_Lorry_CIF : CustomerInformationFile
+	{
+		public PEV_IEPC_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
+
+		#region Overrides of AbstractCustomerReport
+
+		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+		{
+			Vehicle = _cifFactory.GetPEV_IEPC_LorryVehicleType().GetElement(inputData);
+			GenerateReport("PEV_IEPC_LorryVehicleType");
+		}
+
+		#endregion
+	}
+
+    #endregion
+
+
+
+
+
+
+
+
+
+    #region CompletedBus
+    public class Conventional_CompletedBusCIF : CustomerInformationFile
+    {
+        public Conventional_CompletedBusCIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory)
+        {
+        }
+
+        public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+        {
+			Vehicle = _cifFactory.GetConventional_CompletedBusVehicleType().GetElement(inputData);
+			GenerateReport("Conventional_CompletedBusOutputType");
+        }
+    }
+
+
+	public class HEV_CompletedBusCIF : CustomerInformationFile
+	{
+		public HEV_CompletedBusCIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory)
+		{
+		}
+
+		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+		{
+			Vehicle = _cifFactory.GetHEV_CompletedBusVehicleType().GetElement(inputData);
+			GenerateReport("HEV_CompltedBusOutputType");
+		}
+	}
+
+	public class PEV_CompletedBusCIF : CustomerInformationFile
+	{
+		public PEV_CompletedBusCIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory)
+		{
+		}
+
+		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
+		{
+			Vehicle = _cifFactory.GetPEV_CompletedBusVehicleType().GetElement(inputData);
+			GenerateReport("PEV_CompltedBusOutputType");
+		}
+	}
+
+	#endregion
+}
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CustomerInformationFile/LorryCustomerInformationFile.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CustomerInformationFile/LorryCustomerInformationFile.cs
deleted file mode 100644
index a1d0cc98a54336fed2dcfc5d384099b84db54dcb..0000000000000000000000000000000000000000
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CustomerInformationFile/LorryCustomerInformationFile.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Xml.Linq;
-using TUGraz.VectoCommon.InputData;
-using TUGraz.VectoCore.Models.Declaration;
-using TUGraz.VectoCore.Models.Simulation.Data;
-using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportXMLTypeWriter;
-
-namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile.CustomerInformationFile_0_9.CustomerInformationFile
-{
-    public abstract class LorryCustomerInformationFile : AbstractCustomerReport
-    {
-		//protected XNamespace _cif = XNamespace.Get("urn:tugraz:ivt:VectoAPI:DeclarationOutput:v0.9");
-		//public LorryManufacturerReportBase(IManufacturerReportFactory MRFReportFactory) : base(MRFReportFactory) { }
-
-		//protected void GenerateReport(string outputDataType)
-		//{
-		//	Report = new XDocument(new XElement(_mrf + "VectoOutput",
-		//		new XAttribute("xmlns", _mrf),
-		//		new XAttribute(XNamespace.Xmlns + "xsi", xsi),
-		//		new XAttribute(xsi + "type", $"{outputDataType}"),
-		//		Vehicle,
-		//		new XElement(_mrf + "Results")));
-		//}
-
-		protected LorryCustomerInformationFile(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
-	}
-
-	public class ConventionalLorry_CIF : LorryCustomerInformationFile
-	{
-		public ConventionalLorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
-
-		#region Overrides of AbstractCustomerReport
-
-		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
-		{
-			Vehicle = _cifFactory.GetConventionalLorryVehicleType().GetElement(inputData);
-		}
-
-		#endregion
-	}
-
-	public class HEV_PxLorry_CIF : LorryCustomerInformationFile
-	{
-		public HEV_PxLorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
-
-		#region Overrides of AbstractCustomerReport
-
-		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
-		{
-			var vehicle = _cifFactory.GetHEV_PxLorryVehicleType();
-			Vehicle = _cifFactory.GetHEV_PxLorryVehicleType().GetElement(inputData);
-		}
-		#endregion
-	}
-
-	public class HEV_S2_Lorry_CIF : LorryCustomerInformationFile
-	{
-		public HEV_S2_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
-
-		#region Overrides of AbstractCustomerReport
-
-		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
-		{
-			throw new NotImplementedException();
-		}
-
-		#endregion
-	}
-
-	public class HEV_S3_Lorry_CIF : LorryCustomerInformationFile
-	{
-		public HEV_S3_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
-
-		#region Overrides of AbstractCustomerReport
-
-		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
-		{
-			throw new NotImplementedException();
-		}
-
-		#endregion
-	}
-
-	public class HEV_S4_Lorry_CIF : LorryCustomerInformationFile
-	{
-		public HEV_S4_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
-
-		#region Overrides of AbstractCustomerReport
-
-		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
-		{
-			throw new NotImplementedException();
-		}
-
-		#endregion
-	}
-
-	public class HEV_IEPC_Lorry_CIF : LorryCustomerInformationFile
-	{
-		public HEV_IEPC_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
-
-		#region Overrides of AbstractCustomerReport
-
-		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
-		{
-			throw new NotImplementedException();
-		}
-
-		#endregion
-	}
-
-	public class PEV_E2_Lorry_CIF : LorryCustomerInformationFile
-	{
-		public PEV_E2_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
-
-		#region Overrides of AbstractCustomerReport
-
-		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
-		{
-			throw new NotImplementedException();
-		}
-
-		#endregion
-	}
-
-	public class PEV_E3_Lorry_CIF : LorryCustomerInformationFile
-	{
-		public PEV_E3_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
-
-		#region Overrides of AbstractCustomerReport
-
-		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
-		{
-			throw new NotImplementedException();
-		}
-
-		#endregion
-	}
-
-	public class PEV_E4_Lorry_CIF : LorryCustomerInformationFile
-	{
-		public PEV_E4_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
-
-		#region Overrides of AbstractCustomerReport
-
-		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
-		{
-			throw new NotImplementedException();
-		}
-
-		#endregion
-	}
-
-	public class PEV_IEPC_Lorry_CIF : LorryCustomerInformationFile
-	{
-		public PEV_IEPC_Lorry_CIF(ICustomerInformationFileFactory cifFactory) : base(cifFactory) { }
-
-		#region Overrides of AbstractCustomerReport
-
-		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
-		{
-			throw new NotImplementedException();
-		}
-
-		#endregion
-	}
-}
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ICustomerInformationFileFactory.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ICustomerInformationFileFactory.cs
index 08d608bea64d1f0f85b01af317c563cca69f34cf..5ff8e3eae952577d528f766f7b9da615e64b2534 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ICustomerInformationFileFactory.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ICustomerInformationFileFactory.cs
@@ -29,16 +29,24 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
 		IXmlTypeWriter GetPEV_IEPC_LorryVehicleType();
 
 
-		IMrfXmlGroup GetGeneralVehicleSequenceGroupWriter();
-		IMrfXmlGroup GetLorryGeneralVehicleSequenceGroupWriter();
-		IMrfXmlGroup GetConventionalLorryVehicleSequenceGroupWriter();
-		IMrfXmlGroup GetEngineGroup();
-		IMrfXmlGroup GetTransmissionGroup();
-		IMrfXmlGroup GetAxleWheelsGroup();
-		IMrfXmlGroup GetLorryAuxGroup();
-		IMrfXmlGroup GetHEV_VehicleSequenceGroupWriter();
-		IMrfXmlGroup GetHEV_LorryVehicleTypeGroup();
-		IMrfXmlGroup GetElectricMachineGroup();
-		IMrfXmlGroup GetREESSGroup();
+		IXmlTypeWriter GetConventional_CompletedBusVehicleType();
+		IXmlTypeWriter GetHEV_CompletedBusVehicleType();
+		IXmlTypeWriter GetPEV_CompletedBusVehicleType();
+
+
+		IReportVehicleOutputGroup GetGeneralVehicleSequenceGroupWriter();
+		IReportOutputGroup GetLorryGeneralVehicleSequenceGroupWriter();
+		IReportOutputGroup GetConventionalLorryVehicleSequenceGroupWriter();
+		IReportOutputGroup GetEngineGroup();
+		IReportOutputGroup GetTransmissionGroup();
+		IReportOutputGroup GetAxleWheelsGroup();
+		IReportOutputGroup GetLorryAuxGroup();
+		IReportOutputGroup GetHEV_VehicleSequenceGroupWriter();
+		IReportOutputGroup GetHEV_LorryVehicleTypeGroup();
+		IReportOutputGroup GetElectricMachineGroup();
+		IReportOutputGroup GetREESSGroup();
+		IReportOutputGroup GetPEV_LorryVehicleTypeGroup();
+		IReportOutputGroup GetPEV_VehicleSequenceGroupWriter();
+		IReportOutputGroup GetCompletedBusVehicleTypeGroup();
 	}
 }
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/IManufacturerReportFactory.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/IManufacturerReportFactory.cs
index e7c782450f2b055a86a0c615627eab51978475df..4bc193b4959f47d1bc4585c0e2c5b9b05b53fe5d 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/IManufacturerReportFactory.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/IManufacturerReportFactory.cs
@@ -22,6 +22,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 		IXmlTypeWriter GetPEV_E2_LorryVehicleType();
 		IXmlTypeWriter GetPEV_E3_LorryVehicleType();
 		IXmlTypeWriter GetPEV_E4_LorryVehicleType();
+		IXmlTypeWriter GetPEV_IEPC_LorryVehicleType();
 
 
 
@@ -73,18 +74,18 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 
 
 
-		IMrfVehicleGroup GetGeneralVehicleOutputGroup();
+		IReportVehicleOutputGroup GetGeneralVehicleOutputGroup();
 
 
-		IMrfXmlGroup GetGeneralLorryVehicleOutputGroup();
-		IMrfXmlGroup GetHEV_VehicleSequenceGroup();
-		IMrfXmlGroup GetPEV_VehicleSequenceGroup();
-		IMrfXmlGroup GetConventionalLorryVehicleOutputGroup();
-		IMrfXmlGroup GetHEV_lorryVehicleOutputGroup();
-		IMrfXmlGroup GetPEV_lorryVehicleOutputGroup();
-		IMrfXmlGroup GetHEV_lorryVehicleOutputSequenceGroup();
-		IMrfXmlGroup GetPrimaryBusGeneralVehicleOutputGroup();
-		IMrfXmlGroup GetHEV_PrimaryBusVehicleOutputGroup();
+		IReportOutputGroup GetGeneralLorryVehicleOutputGroup();
+		IReportOutputGroup GetHEV_VehicleSequenceGroup();
+		IReportOutputGroup GetPEV_VehicleSequenceGroup();
+		IReportOutputGroup GetConventionalLorryVehicleOutputGroup();
+		IReportOutputGroup GetHEV_lorryVehicleOutputGroup();
+		IReportOutputGroup GetPEV_lorryVehicleOutputGroup();
+		IReportOutputGroup GetHEV_lorryVehicleOutputSequenceGroup();
+		IReportOutputGroup GetPrimaryBusGeneralVehicleOutputGroup();
+		IReportOutputGroup GetHEV_PrimaryBusVehicleOutputGroup();
 
 
 
@@ -130,10 +131,10 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 		IMRFBusAuxiliariesType GetCompletedBusElectricSystemType();
 
 
-		IMrfXmlGroup GetPEV_PrimaryBusVehicleOutputGroup();
-		IMrfXmlGroup GetCompletedBusGeneralVehicleOutputGroup();
-		IMrfVehicleGroup GetCompletedBusSequenceGroup();
-		IMrfVehicleGroup GetCompletedBusDimensionSequenceGroup();
+		IReportOutputGroup GetPEV_PrimaryBusVehicleOutputGroup();
+		IReportOutputGroup GetCompletedBusGeneralVehicleOutputGroup();
+		IReportVehicleOutputGroup GetCompletedBusSequenceGroup();
+		IReportVehicleOutputGroup GetCompletedBusDimensionSequenceGroup();
 		IMrfBusAuxGroup GetCompletedBus_HVACSystemGroup();
 		IMrfVehicleType GetBoostingLimitationsType();
 	}
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/MRFNinjectModule.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/MRFNinjectModule.cs
index db331b36db3cd67a86913e78908af758bbca6971..7e72d6dbc35ff70c76caf6f22505fc67b7432b48 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/MRFNinjectModule.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/MRFNinjectModule.cs
@@ -3,6 +3,8 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Ninject.Activation;
+using Ninject.Extensions.ContextPreservation;
 using Ninject.Extensions.Factory;
 using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Models;
@@ -23,7 +25,6 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
     internal class MRFNinjectModule : AbstractNinjectModule
     {
 
-
 		//IXMLManufacturerReport GetManufacturerReport(string vehicleType, VectoSimulationJobType jobType,
 		//	ArchitectureID archId, bool exempted, bool iepc, bool ihpc);
 		protected static object[] ToParams(string vehicleType, VectoSimulationJobType jobType, ArchitectureID archId,
@@ -80,6 +81,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 
 		public override void Load()
 		{
+			LoadModule<ContextPreservationModule>();
 			Bind<IManufacturerReportFactory>().ToFactory(() => new CombineArgumentsToNameInstanceProvider(nameCombinationMethod, 
 				6, 6, typeof(IManufacturerReportFactory).GetMethod(nameof(IManufacturerReportFactory.GetManufacturerReport)))).InSingletonScope();
 			Bind<IXMLManufacturerReport>().To<ConventionalLorryManufacturerReport>()
@@ -242,53 +244,66 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 					VectoSimulationJobType.ConventionalVehicle,
 					ArchitectureID.UNKNOWN,
 					false,
-					true,
+					false,
+					false)));
+
+			Bind<IXMLManufacturerReport>().To<Conventional_CompletedBusManufacturerReport>().Named(nameCombinationMethod.Invoke(
+				ToParams(VehicleCategoryHelper.CompletedBus,
+					VectoSimulationJobType.ConventionalVehicle,
+					ArchitectureID.UNKNOWN,
+					false,
+					false,
 					false)));
+
 			#region Vehicle
 
-			Bind<IXmlTypeWriter>().To<ConventionalLorryVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<ConventionalLorryVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetConventionalLorryVehicleType());
-			Bind<IXmlTypeWriter>().To<HevPxIhpcLorryVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<HevPxIhpcLorryVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_Px_IHCP_LorryVehicleType());
-			Bind<IXmlTypeWriter>().To<HevS2LorryVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<HevS2LorryVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_S2_LorryVehicleType());
-			Bind<IXmlTypeWriter>().To<HevS3LorryVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<HevS3LorryVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_S3_LorryVehicleType());
-			Bind<IXmlTypeWriter>().To<HevS4LorryVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<HevS4LorryVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_S4_LorryVehicleType());
-			Bind<IXmlTypeWriter>().To<PevE2LorryVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<HevIepcSLorryVehicleTypeWriter>().When(AccessedViaMRFFactory)
+				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_IEPC_S_LorryVehicleType());
+			Bind<IXmlTypeWriter>().To<PevE2LorryVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_E2_LorryVehicleType());
-			Bind<IXmlTypeWriter>().To<PevE3LorryVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<PevE3LorryVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_E3_LorryVehicleType());
-			Bind<IXmlTypeWriter>().To<PevE4LorryVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<PevE4LorryVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_E4_LorryVehicleType());
+			Bind<IXmlTypeWriter>().To<PevIEPCLorryVehicleTypeWriter>().When(AccessedViaMRFFactory)
+				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_IEPC_LorryVehicleType());
 
-			Bind<IXmlTypeWriter>().To<ConventionalPrimaryBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<ConventionalPrimaryBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetConventional_PrimaryBusVehicleType());
-			Bind<IXmlTypeWriter>().To<HevPxIhpcPrimaryBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<HevPxIhpcPrimaryBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_Px_IHPC_PrimaryBusVehicleType());
-			Bind<IXmlTypeWriter>().To<HevS2PrimaryBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<HevS2PrimaryBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_S2_PrimaryBusVehicleType());
-			Bind<IXmlTypeWriter>().To<HevS3PrimaryBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<HevS3PrimaryBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_S3_PrimaryBusVehicleType());
-			Bind<IXmlTypeWriter>().To<HevS4PrimaryBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<HevS4PrimaryBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_S4_PrimaryBusVehicleType());
-			Bind<IXmlTypeWriter>().To<HevIepcSPrimaryBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<HevIepcSPrimaryBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_IEPC_S_PrimaryBusVehicleType());
-			Bind<IXmlTypeWriter>().To<PevE2PrimaryBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<PevE2PrimaryBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_E2_PrimaryBusVehicleType());
-			Bind<IXmlTypeWriter>().To<PevE3PrimaryBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<PevE3PrimaryBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_E3_PrimaryBusVehicleType());
-			Bind<IXmlTypeWriter>().To<PevE4PrimaryBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<PevE4PrimaryBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_E4_PrimaryBusVehicleType());
-			Bind<IXmlTypeWriter>().To<PevIepcPrimaryBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<PevIepcPrimaryBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_IEPC_PrimaryBusVehicleType());
 
-			Bind<IXmlTypeWriter>().To<ConventionalCompletedBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<ConventionalCompletedBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetConventional_CompletedBusVehicleType());
-			Bind<IXmlTypeWriter>().To<HevCompletedBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<HevCompletedBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_CompletedBusVehicleType());
-			Bind<IXmlTypeWriter>().To<PevCompletedBusVehicleTypeWriter>()
+			Bind<IXmlTypeWriter>().To<PevCompletedBusVehicleTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_CompletedBusVehicleType());
 			#endregion
 			#region Components
@@ -346,10 +361,10 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 			#endregion
 
 
-			Bind<IMrfXmlGroup>().To<HEV_VehicleSequenceGroup>()
+			Bind<IReportOutputGroup>().To<HEV_VehicleSequenceGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_VehicleSequenceGroup());
 
-			Bind<IMrfXmlGroup>().To<PEV_VehicleSequenceGroup>()
+			Bind<IReportOutputGroup>().To<PEV_VehicleSequenceGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_VehicleSequenceGroup());
 			#region ADAS
 			Bind<IMRFAdasType>().To<MRFConventionalAdasType>()
@@ -360,136 +375,149 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEVADASType());
 
 			#endregion ADAS
-			Bind<IXmlTypeWriter>().To<TorqueLimitationsTypeWriter>().
-				NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetEngineTorqueLimitationsType());
+			Bind<IXmlTypeWriter>().To<TorqueLimitationsTypeWriter>().When(AccessedViaMRFFactory)
+				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetEngineTorqueLimitationsType());
 
-			Bind<IXmlTypeWriter>().To<EngineTypeWriter>()
+			Bind<IXmlTypeWriter>().To<EngineTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetEngineType());
 
 
 
-			Bind<IXmlTypeWriter>().To<TransmissionTypeWriter>()
+			Bind<IXmlTypeWriter>().To<TransmissionTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetTransmissionType());
 
-			Bind<IXmlTypeWriter>().To<RetarderTypeWriter>()
+			Bind<IXmlTypeWriter>().To<RetarderTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetRetarderType());
 
-			Bind<IXmlTypeWriter>().To<TorqueConverterTypeWriter>()
+			Bind<IXmlTypeWriter>().To<TorqueConverterTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetTorqueConverterType());
 
-			Bind<IXmlTypeWriter>().To<AngleDriveTypeWriter>()
+			Bind<IXmlTypeWriter>().To<AngleDriveTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetAngleDriveType());
 
-			Bind<IMrfAirdragType>().To<MRFAirdragType>()
+			Bind<IMrfAirdragType>().To<MRFAirdragType>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetAirdragType());
 
-			Bind<IXmlTypeWriter>().To<AxleWheelsTypeWriter>()
+			Bind<IXmlTypeWriter>().To<AxleWheelsTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetAxleWheelsType());
 
-			Bind<IXmlTypeWriter>().To<AxleGearTypeWriter>()
+			Bind<IXmlTypeWriter>().To<AxleGearTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetAxleGearType());
 
-			Bind<IXmlTypeWriter>().To<ElectricMachinesTypeWriter>()
+			Bind<IXmlTypeWriter>().To<ElectricMachinesTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetElectricMachinesType());
 
-			Bind<IXmlTypeWriter>().To<MrfiepcSpecificationsTypeWriter>()
+			Bind<IXmlTypeWriter>().To<MrfiepcSpecificationsTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetIEPCSpecifications());
 
-			Bind<IXmlTypeWriter>().To<MrfreessSpecificationsTypeWriter>()
+			Bind<IXmlTypeWriter>().To<MrfreessSpecificationsTypeWriter>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetREESSSpecificationsType());
 
-			Bind<IMrfVehicleType>().To<MRFBoostingLimitationsType>()
+			Bind<IMrfVehicleType>().To<MRFBoostingLimitationsType>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetBoostingLimitationsType());
 
 			#region Auxiliaries
-			Bind<IMRFLorryAuxiliariesType>().To<MRFConventionalLorryAuxiliariesType>()
+			Bind<IMRFLorryAuxiliariesType>().To<MRFConventionalLorryAuxiliariesType>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetConventionalLorryAuxType());
-			Bind<IMRFLorryAuxiliariesType>().To<MRFHEV_LorryAuxiliariesType>()
+			Bind<IMRFLorryAuxiliariesType>().To<MRFHEV_LorryAuxiliariesType>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_LorryAuxiliariesType());
-			Bind<IMRFLorryAuxiliariesType>().To<MRFPEV_LorryAuxiliariesType>()
+			Bind<IMRFLorryAuxiliariesType>().To<MRFPEV_LorryAuxiliariesType>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_LorryAuxiliariesType());
 			
-			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusAuxType_Conventional>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusAuxType_Conventional>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPrimaryBusAuxType_Conventional());
-			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusAuxType_HEV_P>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusAuxType_HEV_P>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPrimaryBusAuxType_HEV_P());
-			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusAuxType_HEV_S>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusAuxType_HEV_S>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPrimaryBusAuxType_HEV_S());
-			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusAuxType_PEV>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusAuxType_PEV>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPrimaryBusAuxType_PEV());
 
-			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusPneumaticSystemType_Conventional_Hev_Px>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusPneumaticSystemType_Conventional_Hev_Px>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPrimaryBusPneumaticSystemType_Conventional_HEV_Px());
-			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusPneumaticSystemType_HEV_S>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusPneumaticSystemType_HEV_S>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPrimaryBusPneumaticSystemType_HEV_S());
-			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusPneumaticSystemType_PEV_IEPC>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusPneumaticSystemType_PEV_IEPC>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPrimaryBusPneumaticSystemType_PEV_IEPC());
 
 
 
-			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusElectricSystemType_Conventional_HEV>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusElectricSystemType_Conventional_HEV>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPrimaryBusElectricSystemType_Conventional_HEV());
 
-			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusElectricSystemType_PEV>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusElectricSystemType_PEV>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPrimaryBusElectricSystemType_PEV());
 			
-			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusHVACSystemType_Conventional_HEV>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusHVACSystemType_Conventional_HEV>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPrimaryBusHVACSystemType_Conventional_HEV());
 
-			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusHVACSystemType_PEV>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFPrimaryBusHVACSystemType_PEV>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPrimaryBusHVACSystemType_PEV());
 
-			Bind<IMRFBusAuxiliariesType>().To<MRFConventionalCompletedBusAuxType>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFConventionalCompletedBusAuxType>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetConventionalCompletedBusAuxType());
 
-			Bind<IMRFBusAuxiliariesType>().To<MRFConventionalCompletedBus_HVACSystemType>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFConventionalCompletedBus_HVACSystemType>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetConventionalCompletedBus_HVACSystemType());
 
-			Bind<IMRFBusAuxiliariesType>().To<MRFCompletedBusElectricSystemType>()
+			Bind<IMRFBusAuxiliariesType>().To<MRFCompletedBusElectricSystemType>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetCompletedBusElectricSystemType());
 
 			#region Groups
 
-			Bind<IMrfVehicleGroup>().To<GeneralVehicleOutputXmlGroup>()
+			Bind<IReportVehicleOutputGroup>().To<GeneralVehicleOutputOutputXmlGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetGeneralVehicleOutputGroup());
 
-			Bind<IMrfXmlGroup>().To<LorryGeneralVehicleOutputXmlGroup>()
+			Bind<IReportOutputGroup>().To<LorryGeneralVehicleOutputXmlGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetGeneralLorryVehicleOutputGroup());
 
-			Bind<IMrfXmlGroup>().To<ConventionalLorryVehicleXmlGroup>()
+			Bind<IReportOutputGroup>().To<ConventionalLorryVehicleXmlGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetConventionalLorryVehicleOutputGroup());
 			
-			Bind<IMrfXmlGroup>().To<PrimaryBusGeneralVehicleOutputGroup>()
+			Bind<IReportOutputGroup>().To<PrimaryBusGeneralVehicleOutputGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPrimaryBusGeneralVehicleOutputGroup());
 
-			Bind<IMrfXmlGroup>().To<HEVPrimaryBusVehicleOutputGroup>()
+			Bind<IReportOutputGroup>().To<HEVPrimaryBusVehicleOutputGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_PrimaryBusVehicleOutputGroup());
 
-			Bind<IMrfXmlGroup>().To<PEVPrimaryBusVehicleOutputGroup>()
+			Bind<IReportOutputGroup>().To<PEVPrimaryBusVehicleOutputGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_PrimaryBusVehicleOutputGroup());
 
-			Bind<IMrfXmlGroup>().To<HEV_LorryVehicleOutputTypeGroup>()
+			Bind<IReportOutputGroup>().To<HEV_LorryVehicleOutputTypeGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_lorryVehicleOutputGroup());
 
-			Bind<IMrfXmlGroup>().To<PEV_LorryVehicleOutputTypeGroup>()
+			Bind<IReportOutputGroup>().To<PEV_LorryVehicleOutputTypeGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetPEV_lorryVehicleOutputGroup());
-			Bind<IMrfXmlGroup>().To<HEV_LorryVehicleOutputTypeSequenceGroup>()
+
+			Bind<IReportOutputGroup>().To<HEV_LorryVehicleOutputTypeSequenceGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetHEV_lorryVehicleOutputSequenceGroup());
 
-			Bind<IMrfVehicleGroup>().To<CompletedBusSequenceGroup>()
+			Bind<IReportVehicleOutputGroup>().To<CompletedBusSequenceOutputGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetCompletedBusSequenceGroup());
 
-			Bind<IMrfVehicleGroup>().To<CompletedBusDimensionsSequenceGroup>()
+			Bind<IReportVehicleOutputGroup>().To<CompletedBusDimensionsSequenceOutputGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetCompletedBusDimensionSequenceGroup());
 
-			Bind<IMrfXmlGroup>().To<CompletedBusGeneralVehicleOutputGroup>()
+			Bind<IReportOutputGroup>().To<CompletedBusGeneralVehicleOutputGroup>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetCompletedBusGeneralVehicleOutputGroup());
 
 
-			Bind<IMrfBusAuxGroup>().To<CompletedBus_HVACSystem_Group>()
+			Bind<IMrfBusAuxGroup>().To<CompletedBus_HVACSystem_Group>().When(AccessedViaMRFFactory)
 				.NamedLikeFactoryMethod((IManufacturerReportFactory f) => f.GetCompletedBus_HVACSystemGroup());
 
 			#endregion
+
+
+
+		}
+
+		private bool AccessedViaMRFFactory(IRequest request)
+		{
+			if (request.ParentRequest == null)
+			{
+				return false;
+			}
+			return typeof(IManufacturerReportFactory).IsAssignableFrom(request.ParentRequest.Service);
 		}
 
 		#endregion
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReport/LorryManufacturerReports.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReport/LorryManufacturerReports.cs
index cb2e76c99a4125f5b08c2d4aa303bfeead054fa8..6daf73c0d33c52d2376cad2227f924c49cd5fbef 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReport/LorryManufacturerReports.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReport/LorryManufacturerReports.cs
@@ -6,17 +6,17 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 {
 	internal abstract class LorryManufacturerReportBase : AbstractManufacturerReport
 	{
-		protected XNamespace _mrf = XNamespace.Get("urn:tugraz:ivt:VectoAPI:DeclarationOutput:v0.9");
+		public static XNamespace Mrf => XNamespace.Get("urn:tugraz:ivt:VectoAPI:DeclarationOutput:v0.9");
 		public LorryManufacturerReportBase(IManufacturerReportFactory MRFReportFactory) : base(MRFReportFactory) { }
 
 		protected void GenerateReport(string outputDataType)
 		{
-			Report = new XDocument(new XElement(_mrf + "VectoOutput",
-				new XAttribute("xmlns", _mrf),
+			Report = new XDocument(new XElement(Mrf + "VectoOutput",
+				new XAttribute("xmlns", Mrf),
 				new XAttribute(XNamespace.Xmlns + "xsi", xsi),
 				new XAttribute(xsi + "type", $"{outputDataType}"),
 				Vehicle,
-				new XElement(_mrf + "Results")));
+				new XElement(Mrf + "Results")));
 		}
 	}
 
@@ -117,7 +117,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 
 		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
 		{
-			Vehicle = _mRFReportFactory.GetHEV_IEPC_S_LorryComponentsType().GetElement(inputData);
+			Vehicle = _mRFReportFactory.GetHEV_IEPC_S_LorryVehicleType().GetElement(inputData);
 			GenerateReport("HEV-IEPC-S_LorryManufacturerOutputDataType");
 		}
 
@@ -177,7 +177,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 
 		public override void InitializeVehicleData(IDeclarationInputDataProvider inputData)
 		{
-			Vehicle = _mRFReportFactory.GetHEV_IEPC_S_LorryVehicleType().GetElement(inputData);
+			Vehicle = _mRFReportFactory.GetPEV_IEPC_LorryVehicleType().GetElement(inputData);
 			GenerateReport("PEV-IEPC_LorryManufacturerOutputDataType");
 		}
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/AbstractMRFGroupWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/AbstractMRFGroupWriter.cs
index 5687a511a99f9f8fed061483fb4d2f2df4311768..774bb4c771bf63614342fdbe9c4f38fb3d856ee4 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/AbstractMRFGroupWriter.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/AbstractMRFGroupWriter.cs
@@ -9,12 +9,12 @@ using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.Manu
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter
 {
-    public abstract class AbstractMrfXmlGroup : IMrfXmlGroup
+    public abstract class AbstractReportOutputGroup : IReportOutputGroup
     {
 		protected readonly IManufacturerReportFactory _mrfFactory;
 		protected XNamespace _mrf = "urn:tugraz:ivt:VectoAPI:DeclarationOutput:v0.9";
 
-		protected AbstractMrfXmlGroup(IManufacturerReportFactory mrfFactory)
+		protected AbstractReportOutputGroup(IManufacturerReportFactory mrfFactory)
 		{
 			_mrfFactory = mrfFactory;
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Common/GeneralVehicleOutputXmlGroup.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Common/GeneralVehicleOutputXmlGroup.cs
index d4067c49f84b0af0d0aa687d452f92c2f3e05cc9..5d48693b79ccebf01e32d4cd5df18c7c65d91e11 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Common/GeneralVehicleOutputXmlGroup.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Common/GeneralVehicleOutputXmlGroup.cs
@@ -13,9 +13,9 @@ using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.Manu
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter
 {
-    public class GeneralVehicleOutputXmlGroup : AbstractMrfXmlGroup, IMrfVehicleGroup
+    public class GeneralVehicleOutputOutputXmlGroup : AbstractReportOutputGroup, IReportVehicleOutputGroup
     {
-		public GeneralVehicleOutputXmlGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
+		public GeneralVehicleOutputOutputXmlGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
 		#region Overrides of AbstractMRFGroupWriter
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Common/HEV-VehicleSequenceGroup.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Common/HEV-VehicleSequenceGroup.cs
index b943868e58a9524d0b71d7c1bb2885f5b8adf258..abf82605827eeb9588fb4547a3cbdcfbc684be09 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Common/HEV-VehicleSequenceGroup.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Common/HEV-VehicleSequenceGroup.cs
@@ -10,7 +10,7 @@ using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.Manu
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter.Vehicle.Lorry
 {
-    internal class HEV_VehicleSequenceGroup : AbstractMrfXmlGroup
+    internal class HEV_VehicleSequenceGroup : AbstractReportOutputGroup
     {
 		public HEV_VehicleSequenceGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Common/PEV-VehicleSequenceGroup .cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Common/PEV-VehicleSequenceGroup .cs
index 9acfb84c1e37a2f2a2baf54b2a611ad00a510729..4bd4d0813db45de7b05840232031080ce57de408 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Common/PEV-VehicleSequenceGroup .cs	
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Common/PEV-VehicleSequenceGroup .cs	
@@ -10,7 +10,7 @@ using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.Manu
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter.Vehicle.Lorry
 {
-    internal class PEV_VehicleSequenceGroup : AbstractMrfXmlGroup
+    internal class PEV_VehicleSequenceGroup : AbstractReportOutputGroup
     {
 		public PEV_VehicleSequenceGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/CompletedBus/CompletedBus.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/CompletedBus/CompletedBus.cs
index 5c04d5924efb474595802887e6c6dab16b84fbf2..787aedd85d08928fe4508759df19b44ffcbb18f9 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/CompletedBus/CompletedBus.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/CompletedBus/CompletedBus.cs
@@ -11,7 +11,7 @@ using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.Manu
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter.Vehicle.CompletedBus
 {
-    internal class CompletedBusGeneralVehicleOutputGroup : AbstractMrfXmlGroup
+    internal class CompletedBusGeneralVehicleOutputGroup : AbstractReportOutputGroup
     {
 		public CompletedBusGeneralVehicleOutputGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
@@ -55,9 +55,9 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 		#endregion
 	}
 
-	internal class CompletedBusSequenceGroup : AbstractMrfXmlGroup, IMrfVehicleGroup
+	internal class CompletedBusSequenceOutputGroup : AbstractReportOutputGroup, IReportVehicleOutputGroup
 	{
-		public CompletedBusSequenceGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
+		public CompletedBusSequenceOutputGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
 		#region Overrides of AbstractMrfXmlGroup
 
@@ -88,9 +88,9 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 		#endregion
 	}
 
-	internal class CompletedBusDimensionsSequenceGroup : AbstractMrfXmlGroup, IMrfVehicleGroup
+	internal class CompletedBusDimensionsSequenceOutputGroup : AbstractReportOutputGroup, IReportVehicleOutputGroup
 	{
-		public CompletedBusDimensionsSequenceGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
+		public CompletedBusDimensionsSequenceOutputGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
 		#region Overrides of AbstractMrfXmlGroup
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/CompletedBus/CompletedBusAuxiliaries.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/CompletedBus/CompletedBusAuxiliaries.cs
index 13e658f0339f0704d903b1144705da1ff4a2a8de..84a720031650f78b57d6cbe198e3b6019b20ac71 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/CompletedBus/CompletedBusAuxiliaries.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/CompletedBus/CompletedBusAuxiliaries.cs
@@ -16,7 +16,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 		IList<XElement> GetElements(IBusAuxiliariesDeclarationData busAuxiliaries);
 
 	}
-    internal class CompletedBus_HVACSystem_Group : AbstractMrfXmlGroup, IMrfBusAuxGroup
+    internal class CompletedBus_HVACSystem_Group : AbstractReportOutputGroup, IMrfBusAuxGroup
     {
 		public CompletedBus_HVACSystem_Group(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/IMRFGroupWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/IMRFGroupWriter.cs
index ab9eb81082d9a4bc28231538c9853561f1568fe8..b8135ad5dfd616ceb2075cdb5845a5a3837dbbd6 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/IMRFGroupWriter.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/IMRFGroupWriter.cs
@@ -8,12 +8,12 @@ using TUGraz.VectoCommon.InputData;
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter
 {
-    public interface IMrfXmlGroup
+    public interface IReportOutputGroup
 	{
 		IList<XElement> GetElements(IDeclarationInputDataProvider inputData);
     }
 
-	public interface IMrfVehicleGroup
+	public interface IReportVehicleOutputGroup
 	{
 		IList<XElement> GetElements(IVehicleDeclarationInputData vehicleData);
 	}
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/ConventionalLorryVehicleGroup.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/ConventionalLorryVehicleGroup.cs
index f3391306a39e12b0cd7c1e9b17b89eaccde7edf0..a96ee2f89636dcf1f79e49550d699771fc24aae7 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/ConventionalLorryVehicleGroup.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/ConventionalLorryVehicleGroup.cs
@@ -10,7 +10,7 @@ using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.Manu
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter
 {
-    public class ConventionalLorryVehicleXmlGroup : AbstractMrfXmlGroup
+    public class ConventionalLorryVehicleXmlGroup : AbstractReportOutputGroup
     {
 		public ConventionalLorryVehicleXmlGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/HEV_LorryVehicleOutputTypeGroup.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/HEV_LorryVehicleOutputTypeGroup.cs
index 26cc62bd988d90c3a7e6785c17a896696c706c4e..b12fe6f5d4b56ac44e27076358f72411dc9cbdc4 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/HEV_LorryVehicleOutputTypeGroup.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/HEV_LorryVehicleOutputTypeGroup.cs
@@ -9,7 +9,7 @@ using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.Manu
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter.Vehicle.Lorry
 {
-    internal class HEV_LorryVehicleOutputTypeGroup : AbstractMrfXmlGroup
+    internal class HEV_LorryVehicleOutputTypeGroup : AbstractReportOutputGroup
     {
 		public HEV_LorryVehicleOutputTypeGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/HEV_LorryVehicleOutputTypeSequenceGroup.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/HEV_LorryVehicleOutputTypeSequenceGroup.cs
index 6036263247c7655ce61aefd65645cd0c3be9e13f..7e50079967a7c5c25e3395f9b1563d00d83f3fd9 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/HEV_LorryVehicleOutputTypeSequenceGroup.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/HEV_LorryVehicleOutputTypeSequenceGroup.cs
@@ -6,7 +6,7 @@ using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.Manu
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter.Lorry
 {
-    internal class HEV_LorryVehicleOutputTypeSequenceGroup : AbstractMrfXmlGroup
+    internal class HEV_LorryVehicleOutputTypeSequenceGroup : AbstractReportOutputGroup
     {
 		public HEV_LorryVehicleOutputTypeSequenceGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/LorryGeneralVehicleOutputGroup.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/LorryGeneralVehicleOutputGroup.cs
index cfacd8091258aa5c81315d107f87ec9e16ec3ee6..82606a7d45f5ae251a4bdeb4c1dcbac4a84a410e 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/LorryGeneralVehicleOutputGroup.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/LorryGeneralVehicleOutputGroup.cs
@@ -11,7 +11,7 @@ using TUGraz.VectoCore.Utils;
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter
 {
-    public class LorryGeneralVehicleOutputXmlGroup : AbstractMrfXmlGroup
+    public class LorryGeneralVehicleOutputXmlGroup : AbstractReportOutputGroup
     {
 		#region Implementation of IMRFGroupWriter
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/PEV_LorryVehicleOutputTypeGroup.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/PEV_LorryVehicleOutputTypeGroup.cs
index 75bdd7dce117f801560296571621601c79b7f88c..cafbce3adc373f2970924cebdf8a18e1d83f3a37 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/PEV_LorryVehicleOutputTypeGroup.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/Lorry/PEV_LorryVehicleOutputTypeGroup.cs
@@ -10,7 +10,7 @@ using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.Manu
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter.Vehicle.Lorry
 {
-    internal class PEV_LorryVehicleOutputTypeGroup : AbstractMrfXmlGroup
+    internal class PEV_LorryVehicleOutputTypeGroup : AbstractReportOutputGroup
     {
 		public PEV_LorryVehicleOutputTypeGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/PrimaryBus/PrimaryBus.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/PrimaryBus/PrimaryBus.cs
index 44c18369658dc5a157e51644888ece82035bada0..b35e751382724fd8ca2e5bbaa85b28a950032ba7 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/PrimaryBus/PrimaryBus.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportGroupWriter/PrimaryBus/PrimaryBus.cs
@@ -11,7 +11,7 @@ using TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.Manu
 
 namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.ManufacturerReport_0_9.ManufacturerReportGroupWriter.Vehicle
 {
-    internal class PrimaryBusGeneralVehicleOutputGroup : AbstractMrfXmlGroup
+    internal class PrimaryBusGeneralVehicleOutputGroup : AbstractReportOutputGroup
     {
 		public PrimaryBusGeneralVehicleOutputGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
@@ -35,7 +35,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 		#endregion
 	}
 
-	internal class HEVPrimaryBusVehicleOutputGroup : AbstractMrfXmlGroup
+	internal class HEVPrimaryBusVehicleOutputGroup : AbstractReportOutputGroup
 	{
 		public HEVPrimaryBusVehicleOutputGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
@@ -53,7 +53,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 		#endregion
 	}
 
-	internal class PEVPrimaryBusVehicleOutputGroup : AbstractMrfXmlGroup
+	internal class PEVPrimaryBusVehicleOutputGroup : AbstractReportOutputGroup
 	{
 		public PEVPrimaryBusVehicleOutputGroup(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
 
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportXMLTypeWriter/MRFVehicleWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportXMLTypeWriter/MRFVehicleWriter.cs
index a0ca4a3fad85247c5d4078563421c7194382d707..6c049fd5e55aa00a139cab308a4fe1f279bea854 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportXMLTypeWriter/MRFVehicleWriter.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ManufacturerReportXMLTypeWriter/MRFVehicleWriter.cs
@@ -180,6 +180,22 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.ManufacturerReport.
 		#endregion
 	}
 
+	public class PevIEPCLorryVehicleTypeWriter : VehicleTypeWriter
+	{
+		public PevIEPCLorryVehicleTypeWriter(IManufacturerReportFactory mrfFactory) : base(mrfFactory) { }
+
+		#region Overrides of AbstractMrfXmlType
+
+		public override XElement GetElement(IDeclarationInputDataProvider inputData)
+		{
+			return new XElement(_mrf + XMLNames.Component_Vehicle,
+				_mrfFactory.GetPEV_lorryVehicleOutputGroup().GetElements(inputData),
+				_mrfFactory.GetPEV_IEPC_S_LorryComponentsType().GetElement(inputData));
+		}
+
+		#endregion
+	}
+
 
 
 
diff --git a/VectoCore/VectoCore/Resources/XSD/VectoOutputCustomer.0.9.xsd b/VectoCore/VectoCore/Resources/XSD/VectoOutputCustomer.0.9.xsd
index a28688d82feca8301b2c7bbe71e2cb630289c097..3b3a4177ac5ee01b6ce25d47dca6af7d7809dd76 100644
--- a/VectoCore/VectoCore/Resources/XSD/VectoOutputCustomer.0.9.xsd
+++ b/VectoCore/VectoCore/Resources/XSD/VectoOutputCustomer.0.9.xsd
@@ -1,6 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!-- edited with XMLSpy v2016 rel. 2 sp1 (x64) (http://www.altova.com) by Helmut Eichlseder (TU Graz/Inst. f. VKM und THD) -->
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="urn:tugraz:ivt:VectoAPI:CustomerOutput:v0.9" xmlns:out="urn:tugraz:ivt:VectoAPI:DeclarationOutputDefinitions" xmlns:mrf="urn:tugraz:ivt:VectoAPI:DeclarationOutput:v0.9" targetNamespace="urn:tugraz:ivt:VectoAPI:CustomerOutput:v0.9" elementFormDefault="qualified" attributeFormDefault="unqualified">
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+xmlns="urn:tugraz:ivt:VectoAPI:CustomerOutput:v0.9" 
+xmlns:out="urn:tugraz:ivt:VectoAPI:DeclarationOutputDefinitions" 
+xmlns:mrf="urn:tugraz:ivt:VectoAPI:DeclarationOutput:v0.9" 
+targetNamespace="urn:tugraz:ivt:VectoAPI:CustomerOutput:v0.9" 
+elementFormDefault="qualified" attributeFormDefault="unqualified">
 	<xs:import namespace="urn:tugraz:ivt:VectoAPI:DeclarationOutput:v0.9" schemaLocation="VectoOutputManufacturer.0.9.xsd"/>
 	<xs:import namespace="urn:tugraz:ivt:VectoAPI:DeclarationOutputDefinitions" schemaLocation="VectoOutputDefinitions.xsd"/>
 	<xs:element name="VectoOutput">
@@ -277,7 +282,7 @@
 	</xs:complexType>
 	<xs:group name="GeneralVehicleSequenceGroup">
 		<xs:sequence>
-			<xs:element name="VehicleIdentifiationNumber"/>
+			<xs:element name="VIN"/>
 			<xs:element name="VehicleCategory"/>
 			<xs:element name="AxleConfiguration"/>
 			<xs:element name="TechnicalPermissibleMaximumLadenMass">
diff --git a/VectoCore/VectoCore/VectoCore.csproj b/VectoCore/VectoCore/VectoCore.csproj
index e55fa01a288430432308c48dc14c5556cbc242ca..bbaa6756f356db693c21e72e78b08ff5d80ee317 100644
--- a/VectoCore/VectoCore/VectoCore.csproj
+++ b/VectoCore/VectoCore/VectoCore.csproj
@@ -101,6 +101,9 @@
       <HintPath>..\..\packages\Ninject.3.3.4\lib\net45\Ninject.dll</HintPath>
       <Private>True</Private>
     </Reference>
+    <Reference Include="Ninject.Extensions.ContextPreservation, Version=3.3.1.0, Culture=neutral, PublicKeyToken=c7192dc5380945e7, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Ninject.Extensions.ContextPreservation.3.3.1\lib\net45\Ninject.Extensions.ContextPreservation.dll</HintPath>
+    </Reference>
     <Reference Include="Ninject.Extensions.Factory, Version=3.3.3.0, Culture=neutral, PublicKeyToken=c7192dc5380945e7, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Ninject.Extensions.Factory.3.3.3\lib\net45\Ninject.Extensions.Factory.dll</HintPath>
     </Reference>
@@ -487,7 +490,7 @@
     <Compile Include="OutputData\XML\DeclarationReports\CustomerInformationFile\CustomerInformationFile_0_9\CIFWriter\ComponentGroupWriters.cs" />
     <Compile Include="OutputData\XML\DeclarationReports\CustomerInformationFile\CustomerInformationFile_0_9\CIFWriter\VehicleGroups.cs" />
     <Compile Include="OutputData\XML\DeclarationReports\CustomerInformationFile\CustomerInformationFile_0_9\CIFWriter\VehicleWriter.cs" />
-    <Compile Include="OutputData\XML\DeclarationReports\CustomerInformationFile\CustomerInformationFile_0_9\CustomerInformationFile\LorryCustomerInformationFile.cs" />
+    <Compile Include="OutputData\XML\DeclarationReports\CustomerInformationFile\CustomerInformationFile_0_9\CustomerInformationFile\CustomerInformationFile.cs" />
     <Compile Include="OutputData\XML\DeclarationReports\CustomerInformationFile\CustomerInformationFile_0_9\ICustomerInformationFileFactory.cs" />
     <Compile Include="OutputData\XML\DeclarationReports\CustomerInformationFile\IXMLCustomerReport.cs" />
     <Compile Include="OutputData\XML\DeclarationReports\CustomerInformationFile\XMLCustomerReportExemptedCompletedBus.cs" />
diff --git a/VectoCore/VectoCoreTest/XML/Reports/CustomerInformationFileWriterTest.cs b/VectoCore/VectoCoreTest/XML/Reports/CustomerInformationFileWriterTest.cs
index 0d8c0a7966d5cd5f894be458209e3106c5253761..2c78b475929c74a33d148df83dfbae58787f2ef0 100644
--- a/VectoCore/VectoCoreTest/XML/Reports/CustomerInformationFileWriterTest.cs
+++ b/VectoCore/VectoCoreTest/XML/Reports/CustomerInformationFileWriterTest.cs
@@ -37,6 +37,28 @@ namespace TUGraz.VectoCore.Tests.XML.Reports
 			return report;
 		}
 
+		private IXMLCustomerReport GetCompletedBusCustomerReport(string fileName,
+	out IMultistageBusInputDataProvider dataProvider)
+		{
+			Assert.IsFalse(string.IsNullOrEmpty(fileName));
+			dataProvider = _xmlReader.CreateDeclaration(fileName) as IMultistageBusInputDataProvider;
+
+			var arch = dataProvider.JobInputData.PrimaryVehicle.Vehicle.ArchitectureID;
+
+			dataProvider.JobInputData.PrimaryVehicle.Vehicle.VehicleCategory.GetVehicleType(); // HEV/PEV - Sx/Px
+			var ihpc = (dataProvider.JobInputData.PrimaryVehicle.Vehicle.Components.ElectricMachines?.Entries)?.Count(electric =>
+				electric.ElectricMachine.IHPCType != "None") > 0;
+			var iepc = (dataProvider.JobInputData.PrimaryVehicle.Vehicle.Components.IEPC != null);
+			var report = _cifFactory.GetCustomerReport(
+				dataProvider.JobInputData.ConsolidateManufacturingStage.Vehicle.VehicleCategory,
+				dataProvider.JobInputData.JobType,
+				arch,
+				dataProvider.JobInputData.PrimaryVehicle.Vehicle.ExemptedVehicle,
+				iepc,
+				ihpc);
+			return report;
+		}
+
 
 		[TestCase(ConventionalHeavyLorry)]
 		public void ConventionalLorryCIFTest(string fileName)
@@ -46,6 +68,7 @@ namespace TUGraz.VectoCore.Tests.XML.Reports
 			report.InitializeVehicleData(dataProvider);
 
 			Assert.IsTrue(ValidateAndPrint(report.Report));
+			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
 		}
 
 
@@ -57,13 +80,107 @@ namespace TUGraz.VectoCore.Tests.XML.Reports
 			report.InitializeVehicleData(dataProvider);
 			
 			Assert.IsTrue(ValidateAndPrint(report.Report));
+			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
 		}
 
+		[TestCase(HEV_S2_HeavyLorry)]
+		public void HEV_S2_LorryCIFTest(string fileName)
+		{
+			var report = GetCustomerReport(fileName, out var dataProvider) as HEV_S2_Lorry_CIF;
+			Assert.NotNull(report);
+			report.InitializeVehicleData(dataProvider);
 
+			Assert.IsTrue(ValidateAndPrint(report.Report));
+			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
+		}
+
+
+		[TestCase(HEV_S3_HeavyLorry)]
+		public void HEV_S3_LorryCIFTest(string fileName)
+		{
+			var report = GetCustomerReport(fileName, out var dataProvider) as HEV_S3_Lorry_CIF;
+			Assert.NotNull(report);
+			report.InitializeVehicleData(dataProvider);
+
+			Assert.IsTrue(ValidateAndPrint(report.Report));
+			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
+		}
 
 
 
+		[TestCase(HEV_S4_HeavyLorry)]
+		public void HEV_S4_LorryCIFTest(string fileName)
+		{
+			var report = GetCustomerReport(fileName, out var dataProvider) as HEV_S4_Lorry_CIF;
+			Assert.NotNull(report);
+			report.InitializeVehicleData(dataProvider);
 
+			Assert.IsTrue(ValidateAndPrint(report.Report));
+			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
+		}
 
+		[TestCase(HEV_IEPC_S_HeavyLorry)]
+		public void HEV_IEPC_S_LorryCIFTest(string fileName)
+		{
+			var report = GetCustomerReport(fileName, out var dataProvider) as HEV_IEPC_Lorry_CIF;
+			Assert.NotNull(report);
+			report.InitializeVehicleData(dataProvider);
+
+			Assert.IsTrue(ValidateAndPrint(report.Report));
+			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
+		}
+
+		[TestCase(PEV_E2_HeavyLorry)]
+		public void PEV_E2_LorryCIFTest(string fileName)
+		{
+			var report = GetCustomerReport(fileName, out var dataProvider) as PEV_E2_Lorry_CIF;
+			Assert.NotNull(report);
+			report.InitializeVehicleData(dataProvider);
+
+			Assert.IsTrue(ValidateAndPrint(report.Report));
+			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
+		}
+
+		[TestCase(PEV_E3_HeavyLorry)]
+		public void PEV_E3_LorryCIFTest(string fileName)
+		{
+			var report = GetCustomerReport(fileName, out var dataProvider) as PEV_E3_Lorry_CIF;
+			Assert.NotNull(report);
+			report.InitializeVehicleData(dataProvider);
+
+			Assert.IsTrue(ValidateAndPrint(report.Report));
+			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
+		}
+		[TestCase(PEV_E4_HeavyLorry)]
+		public void PEV_E4_LorryCIFTest(string fileName)
+		{
+			var report = GetCustomerReport(fileName, out var dataProvider) as PEV_E4_Lorry_CIF;
+			Assert.NotNull(report);
+			report.InitializeVehicleData(dataProvider);
+
+			Assert.IsTrue(ValidateAndPrint(report.Report));
+			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
+		}
+        [TestCase(PEV_IEPC_HeavyLorry)]
+        public void PEV_IEPC_LorryCIFTest(string fileName)
+        {
+            var report = GetCustomerReport(fileName, out var dataProvider) as PEV_IEPC_Lorry_CIF;
+            Assert.NotNull(report);
+            report.InitializeVehicleData(dataProvider);
+
+            Assert.IsTrue(ValidateAndPrint(report.Report));
+			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
+		}
+
+		[TestCase(Conventional_CompletedBus)]
+		public void Conventional_CompletedBus_CIFTest(string fileName)
+		{
+			var report = GetCompletedBusCustomerReport(fileName, out var dataProvider) as Conventional_CompletedBusCIF;
+			Assert.NotNull(report);
+			report.InitializeVehicleData(dataProvider);
+
+			Assert.IsTrue(ValidateAndPrint(report.Report));
+			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
+		}
 	}
 }
diff --git a/VectoCore/VectoCoreTest/XML/Reports/ManufacturerReportWriterTest.cs b/VectoCore/VectoCoreTest/XML/Reports/ManufacturerReportWriterTest.cs
index d99ce2dbb90d4bb9941c040c530ddf2a109cbfd6..a15be9cae914cabdeab8992fc7fa0aea2c53bc69 100644
--- a/VectoCore/VectoCoreTest/XML/Reports/ManufacturerReportWriterTest.cs
+++ b/VectoCore/VectoCoreTest/XML/Reports/ManufacturerReportWriterTest.cs
@@ -56,6 +56,8 @@ namespace TUGraz.VectoCore.Tests.XML.Reports
 			@"TestData\XML\XMLReaderDeclaration\SchemaVersion2.4\Distributed\HeavyLorry\PEV_heavyLorry_E3.xml";
 		protected const string PEV_E4_HeavyLorry = 
 			@"TestData\XML\XMLReaderDeclaration\SchemaVersion2.4\Distributed\HeavyLorry\PEV_heavyLorry_E4.xml";
+		protected const string PEV_IEPC_HeavyLorry =
+			@"TestData\XML\XMLReaderDeclaration\SchemaVersion2.4\Distributed\HeavyLorry\IEPC_heavyLorry.xml";
 
 		protected const string Conventional_PrimaryBus = 
 			@"TestData\XML\XMLReaderDeclaration\SchemaVersion2.4\Distributed\PrimaryBus\Conventional_primaryBus_AMT.xml";
@@ -85,15 +87,10 @@ namespace TUGraz.VectoCore.Tests.XML.Reports
 
 		protected bool ValidateAndPrint(XDocument document)
 		{
-			XmlSchemaSet schemas = new XmlSchemaSet();
 			var error = false;
-			var path = Path.GetFullPath("../../../VectoCore/Resources/XSD/VectoOutputManufacturer.0.9.xsd");
-			TestContext.WriteLine(path);
-			XmlReader reader = new XmlTextReader(path)
-			{
-				XmlResolver = new XmlUrlResolver()
-			};
-			schemas.Add("urn:tugraz:ivt:VectoAPI:DeclarationOutput:v0.9", reader);
+			var schemas = XmlSchemaSet(
+				(Path.GetFullPath("../../../VectoCore/Resources/XSD/VectoOutputManufacturer.0.9.xsd"), "urn:tugraz:ivt:VectoAPI:DeclarationOutput:v0.9"),
+					(Path.GetFullPath("../../../VectoCore/Resources/XSD/VectoOutputCustomer.0.9.xsd"), "urn:tugraz:ivt:VectoAPI:CustomerOutput:v0.9"));
 			document.Validate(schemas, (sender, args) => {
 				error = true;
 
@@ -105,6 +102,23 @@ namespace TUGraz.VectoCore.Tests.XML.Reports
 			return !error;
 		}
 
+		private static XmlSchemaSet XmlSchemaSet(params (string path, string targetNamespace)[] paths)
+		{
+			XmlSchemaSet schemas = new XmlSchemaSet();
+			foreach (var path in paths) {
+				using (XmlReader reader = new XmlTextReader(path.path)
+						{
+							XmlResolver = new XmlUrlResolver()
+
+						})
+				{
+					schemas.Add(path.targetNamespace, reader);
+				};
+				
+			}
+			return schemas;
+		}
+
 		protected bool WriteToDisk(string basePath, string fileName, XDocument xDocument)
 		{
 			TestContext.WriteLine($"{basePath},{fileName}");
@@ -296,6 +310,16 @@ namespace TUGraz.VectoCore.Tests.XML.Reports
 			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
 		}
 
+		[TestCase(PEV_IEPC_HeavyLorry)]
+		public async Task PEV_IEPC_LorryMRFTest(string fileName)
+		{
+			var report = GetReport(fileName, out var dataProvider) as PEV_IEPC_LorryManufacturerReport;
+			Assert.NotNull(report);
+			report.InitializeVehicleData(dataProvider);
+			Assert.IsTrue(ValidateAndPrint(report.Report));
+			Assert.IsTrue(WriteToDisk(outputBasePath, TestContext.CurrentContext.Test.MethodName, report.Report));
+		}
+
 
 		[TestCase(Conventional_PrimaryBus)]
 		public void ConventionalPrimaryBusTest(string fileName)