Physically moves sub files to common folder

Entire-Checkpoint: 01M2B7EDZM8BMGT9TXM3852EZ0

forward-declarations/aes_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace AreaEffectSimulation
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace AreaEffectSimulation

forward-declarations/aes_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace AreaEffectSimulation
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace AreaEffectSimulation

forward-declarations/alm_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace AlarmManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace AlarmManagement

forward-declarations/asm_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace AssetManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace AssetManagement

forward-declarations/asm_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace AssetManagement
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace AssetManagement

forward-declarations/avm_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace AudioVideoManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace AudioVideoManagement

forward-declarations/avm_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace AudioVideoManagement
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace AudioVideoManagement

forward-declarations/bld_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace Buildings
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace Buildings

forward-declarations/bld_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace Buildings
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace Buildings

forward-declarations/ces_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace CentralEffectSimulation
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace CentralEffectSimulation

forward-declarations/cmo_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace ComponentMonitor
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace ComponentMonitor

forward-declarations/cod_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace CodificationManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace CodificationManagement

forward-declarations/core_dtc.h

@@ -0,0 +1,16 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace DDS
+{
+namespace Core
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace Core
+} // namespace DDS

forward-declarations/core_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace Core
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace Core

forward-declarations/eem_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace ExerciseEventManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace ExerciseEventManagement

forward-declarations/eem_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace ExerciseEventManagement
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace ExerciseEventManagement

forward-declarations/esc_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace EffectShowClient
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace EffectShowClient

forward-declarations/esm_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace EffectShowManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace EffectShowManagement

forward-declarations/evl_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace Evaluations
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace Evaluations

forward-declarations/exm_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace ExerciseManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace ExerciseManagement

forward-declarations/exm_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace ExerciseManagement
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace ExerciseManagement

forward-declarations/flm_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace FileManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace FileManagement

forward-declarations/flm_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace FileManagement
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace FileManagement

forward-declarations/generic_dtc.h

@@ -0,0 +1,20 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace DDS
+{
+namespace DTC
+{
+class Dtc;
+class Ftc;
+} // namespace DTC
+} // namespace DDS
+
+// Generic Namespace für generische DDS-Typen
+namespace Generic
+{
+class Dtc;
+class Ftc;
+} // namespace Generic

forward-declarations/gim_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace GuezIedManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace GuezIedManagement

forward-declarations/gna_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace GuezNasat
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace GuezNasat

forward-declarations/ism_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace InfrastructureManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace InfrastructureManagement

forward-declarations/ism_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace InfrastructureManagement
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace InfrastructureManagement

forward-declarations/mdm_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace MeteoDataManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace MeteoDataManagement

forward-declarations/mrk_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace MarkerManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace MarkerManagement

forward-declarations/msg_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace Messaging
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace Messaging

forward-declarations/nom_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace NotificationManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace NotificationManagement

forward-declarations/nom_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace NotificationManagement
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace NotificationManagement

forward-declarations/opm_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace OperatorManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace OperatorManagement

forward-declarations/oss_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace OcSituationServer
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace OcSituationServer

forward-declarations/pdm_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace ProjectDataManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace ProjectDataManagement

forward-declarations/pdm_dtc_types.h

@@ -0,0 +1,385 @@
+
+/**
+* DTC definitions
+*/
+
+// warning: this file is generated with command
+// Lts/Common/CodeGen/codegen_simple.py ALL Lts/Services/ProjectDataManagement/pdm_service.xml build/Lts/Services/ProjectDataManagement/
+// at Sun Sep  6 18:00:15 2026
+// it will be overwritten by next run - do not modify!
+
+#pragma once
+
+#include "pdm.hpp"
+
+/**
+ * Type definitions 
+ *  => DataTopicClients (DTCs)
+ */
+
+namespace DDSGeneric
+{
+template <typename T>
+class GenericDataReader;
+template <typename T>
+class GenericDataReaderContentFilter;
+class DynamicDataReader;
+}
+
+namespace DTC
+{
+   template<typename T> class GenericDtc;
+   template<typename T> class GenericDtcImpl;
+   template<typename T> class GenericDtcSampleInfo;
+   template<typename T> class GenericDtcImplSampleInfo;
+
+  // Topic ProjectDataManagement::BiteComponentText
+  using DroBiteComponentText = DDSGeneric::GenericDataReader<ProjectDataManagement::BiteComponentText>;
+  using BiteComponentText = GenericDtc<DroBiteComponentText>;
+  using BiteComponentTextImpl = GenericDtcImpl<DroBiteComponentText>;
+  using DroBiteComponentTextCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::BiteComponentText>;
+  using BiteComponentTextCF = GenericDtc<DroBiteComponentTextCF>;
+  using BiteComponentTextCFImpl = GenericDtcImpl<DroBiteComponentTextCF>;
+  namespace SampleInfo {
+    using BiteComponentText = GenericDtcSampleInfo<DroBiteComponentText>;
+    using BiteComponentTextImpl = GenericDtcImplSampleInfo<DroBiteComponentText>;
+  }
+
+  // Topic ProjectDataManagement::BuildingChargeEffect
+  using DroBuildingChargeEffect = DDSGeneric::GenericDataReader<ProjectDataManagement::BuildingChargeEffect>;
+  using BuildingChargeEffect = GenericDtc<DroBuildingChargeEffect>;
+  using BuildingChargeEffectImpl = GenericDtcImpl<DroBuildingChargeEffect>;
+  using DroBuildingChargeEffectCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::BuildingChargeEffect>;
+  using BuildingChargeEffectCF = GenericDtc<DroBuildingChargeEffectCF>;
+  using BuildingChargeEffectCFImpl = GenericDtcImpl<DroBuildingChargeEffectCF>;
+  namespace SampleInfo {
+    using BuildingChargeEffect = GenericDtcSampleInfo<DroBuildingChargeEffect>;
+    using BuildingChargeEffectImpl = GenericDtcImplSampleInfo<DroBuildingChargeEffect>;
+  }
+
+  // Topic ProjectDataManagement::CanComponentString
+  using DroCanComponentString = DDSGeneric::GenericDataReader<ProjectDataManagement::CanComponentString>;
+  using CanComponentString = GenericDtc<DroCanComponentString>;
+  using CanComponentStringImpl = GenericDtcImpl<DroCanComponentString>;
+  using DroCanComponentStringCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::CanComponentString>;
+  using CanComponentStringCF = GenericDtc<DroCanComponentStringCF>;
+  using CanComponentStringCFImpl = GenericDtcImpl<DroCanComponentStringCF>;
+  namespace SampleInfo {
+    using CanComponentString = GenericDtcSampleInfo<DroCanComponentString>;
+    using CanComponentStringImpl = GenericDtcImplSampleInfo<DroCanComponentString>;
+  }
+
+  // Topic ProjectDataManagement::ChargeType
+  using DroChargeType = DDSGeneric::GenericDataReader<ProjectDataManagement::ChargeType>;
+  using ChargeType = GenericDtc<DroChargeType>;
+  using ChargeTypeImpl = GenericDtcImpl<DroChargeType>;
+  using DroChargeTypeCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::ChargeType>;
+  using ChargeTypeCF = GenericDtc<DroChargeTypeCF>;
+  using ChargeTypeCFImpl = GenericDtcImpl<DroChargeTypeCF>;
+  namespace SampleInfo {
+    using ChargeType = GenericDtcSampleInfo<DroChargeType>;
+    using ChargeTypeImpl = GenericDtcImplSampleInfo<DroChargeType>;
+  }
+
+  // Topic ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction
+  using DroChargeTypeIgniterTypeIgniterFunction = DDSGeneric::GenericDataReader<ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction>;
+  using ChargeTypeIgniterTypeIgniterFunction = GenericDtc<DroChargeTypeIgniterTypeIgniterFunction>;
+  using ChargeTypeIgniterTypeIgniterFunctionImpl = GenericDtcImpl<DroChargeTypeIgniterTypeIgniterFunction>;
+  using DroChargeTypeIgniterTypeIgniterFunctionCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction>;
+  using ChargeTypeIgniterTypeIgniterFunctionCF = GenericDtc<DroChargeTypeIgniterTypeIgniterFunctionCF>;
+  using ChargeTypeIgniterTypeIgniterFunctionCFImpl = GenericDtcImpl<DroChargeTypeIgniterTypeIgniterFunctionCF>;
+  namespace SampleInfo {
+    using ChargeTypeIgniterTypeIgniterFunction = GenericDtcSampleInfo<DroChargeTypeIgniterTypeIgniterFunction>;
+    using ChargeTypeIgniterTypeIgniterFunctionImpl = GenericDtcImplSampleInfo<DroChargeTypeIgniterTypeIgniterFunction>;
+  }
+
+  // Topic ProjectDataManagement::ChargeTypeLoadType
+  using DroChargeTypeLoadType = DDSGeneric::GenericDataReader<ProjectDataManagement::ChargeTypeLoadType>;
+  using ChargeTypeLoadType = GenericDtc<DroChargeTypeLoadType>;
+  using ChargeTypeLoadTypeImpl = GenericDtcImpl<DroChargeTypeLoadType>;
+  using DroChargeTypeLoadTypeCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::ChargeTypeLoadType>;
+  using ChargeTypeLoadTypeCF = GenericDtc<DroChargeTypeLoadTypeCF>;
+  using ChargeTypeLoadTypeCFImpl = GenericDtcImpl<DroChargeTypeLoadTypeCF>;
+  namespace SampleInfo {
+    using ChargeTypeLoadType = GenericDtcSampleInfo<DroChargeTypeLoadType>;
+    using ChargeTypeLoadTypeImpl = GenericDtcImplSampleInfo<DroChargeTypeLoadType>;
+  }
+
+  // Topic ProjectDataManagement::EquipmentSystemEventFilter
+  using DroEquipmentSystemEventFilter = DDSGeneric::GenericDataReader<ProjectDataManagement::EquipmentSystemEventFilter>;
+  using EquipmentSystemEventFilter = GenericDtc<DroEquipmentSystemEventFilter>;
+  using EquipmentSystemEventFilterImpl = GenericDtcImpl<DroEquipmentSystemEventFilter>;
+  using DroEquipmentSystemEventFilterCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::EquipmentSystemEventFilter>;
+  using EquipmentSystemEventFilterCF = GenericDtc<DroEquipmentSystemEventFilterCF>;
+  using EquipmentSystemEventFilterCFImpl = GenericDtcImpl<DroEquipmentSystemEventFilterCF>;
+  namespace SampleInfo {
+    using EquipmentSystemEventFilter = GenericDtcSampleInfo<DroEquipmentSystemEventFilter>;
+    using EquipmentSystemEventFilterImpl = GenericDtcImplSampleInfo<DroEquipmentSystemEventFilter>;
+  }
+
+  // Topic ProjectDataManagement::EventFilterHgrMineSearch
+  using DroEventFilterHgrMineSearch = DDSGeneric::GenericDataReader<ProjectDataManagement::EventFilterHgrMineSearch>;
+  using EventFilterHgrMineSearch = GenericDtc<DroEventFilterHgrMineSearch>;
+  using EventFilterHgrMineSearchImpl = GenericDtcImpl<DroEventFilterHgrMineSearch>;
+  using DroEventFilterHgrMineSearchCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::EventFilterHgrMineSearch>;
+  using EventFilterHgrMineSearchCF = GenericDtc<DroEventFilterHgrMineSearchCF>;
+  using EventFilterHgrMineSearchCFImpl = GenericDtcImpl<DroEventFilterHgrMineSearchCF>;
+  namespace SampleInfo {
+    using EventFilterHgrMineSearch = GenericDtcSampleInfo<DroEventFilterHgrMineSearch>;
+    using EventFilterHgrMineSearchImpl = GenericDtcImplSampleInfo<DroEventFilterHgrMineSearch>;
+  }
+
+  // Topic ProjectDataManagement::FirePurpose
+  using DroFirePurpose = DDSGeneric::GenericDataReader<ProjectDataManagement::FirePurpose>;
+  using FirePurpose = GenericDtc<DroFirePurpose>;
+  using FirePurposeImpl = GenericDtcImpl<DroFirePurpose>;
+  using DroFirePurposeCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::FirePurpose>;
+  using FirePurposeCF = GenericDtc<DroFirePurposeCF>;
+  using FirePurposeCFImpl = GenericDtcImpl<DroFirePurposeCF>;
+  namespace SampleInfo {
+    using FirePurpose = GenericDtcSampleInfo<DroFirePurpose>;
+    using FirePurposeImpl = GenericDtcImplSampleInfo<DroFirePurpose>;
+  }
+
+  // Topic ProjectDataManagement::GearType
+  using DroGearType = DDSGeneric::GenericDataReader<ProjectDataManagement::GearType>;
+  using GearType = GenericDtc<DroGearType>;
+  using GearTypeImpl = GenericDtcImpl<DroGearType>;
+  using DroGearTypeCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::GearType>;
+  using GearTypeCF = GenericDtc<DroGearTypeCF>;
+  using GearTypeCFImpl = GenericDtcImpl<DroGearTypeCF>;
+  namespace SampleInfo {
+    using GearType = GenericDtcSampleInfo<DroGearType>;
+    using GearTypeImpl = GenericDtcImplSampleInfo<DroGearType>;
+  }
+
+  // Topic ProjectDataManagement::GearTypeChargeType
+  using DroGearTypeChargeType = DDSGeneric::GenericDataReader<ProjectDataManagement::GearTypeChargeType>;
+  using GearTypeChargeType = GenericDtc<DroGearTypeChargeType>;
+  using GearTypeChargeTypeImpl = GenericDtcImpl<DroGearTypeChargeType>;
+  using DroGearTypeChargeTypeCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::GearTypeChargeType>;
+  using GearTypeChargeTypeCF = GenericDtc<DroGearTypeChargeTypeCF>;
+  using GearTypeChargeTypeCFImpl = GenericDtcImpl<DroGearTypeChargeTypeCF>;
+  namespace SampleInfo {
+    using GearTypeChargeType = GenericDtcSampleInfo<DroGearTypeChargeType>;
+    using GearTypeChargeTypeImpl = GenericDtcImplSampleInfo<DroGearTypeChargeType>;
+  }
+
+  // Topic ProjectDataManagement::IgniterFunction
+  using DroIgniterFunction = DDSGeneric::GenericDataReader<ProjectDataManagement::IgniterFunction>;
+  using IgniterFunction = GenericDtc<DroIgniterFunction>;
+  using IgniterFunctionImpl = GenericDtcImpl<DroIgniterFunction>;
+  using DroIgniterFunctionCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::IgniterFunction>;
+  using IgniterFunctionCF = GenericDtc<DroIgniterFunctionCF>;
+  using IgniterFunctionCFImpl = GenericDtcImpl<DroIgniterFunctionCF>;
+  namespace SampleInfo {
+    using IgniterFunction = GenericDtcSampleInfo<DroIgniterFunction>;
+    using IgniterFunctionImpl = GenericDtcImplSampleInfo<DroIgniterFunction>;
+  }
+
+  // Topic ProjectDataManagement::IgniterType
+  using DroIgniterType = DDSGeneric::GenericDataReader<ProjectDataManagement::IgniterType>;
+  using IgniterType = GenericDtc<DroIgniterType>;
+  using IgniterTypeImpl = GenericDtcImpl<DroIgniterType>;
+  using DroIgniterTypeCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::IgniterType>;
+  using IgniterTypeCF = GenericDtc<DroIgniterTypeCF>;
+  using IgniterTypeCFImpl = GenericDtcImpl<DroIgniterTypeCF>;
+  namespace SampleInfo {
+    using IgniterType = GenericDtcSampleInfo<DroIgniterType>;
+    using IgniterTypeImpl = GenericDtcImplSampleInfo<DroIgniterType>;
+  }
+
+  // Topic ProjectDataManagement::LanguageHmi
+  using DroLanguageHmi = DDSGeneric::GenericDataReader<ProjectDataManagement::LanguageHmi>;
+  using LanguageHmi = GenericDtc<DroLanguageHmi>;
+  using LanguageHmiImpl = GenericDtcImpl<DroLanguageHmi>;
+  using DroLanguageHmiCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::LanguageHmi>;
+  using LanguageHmiCF = GenericDtc<DroLanguageHmiCF>;
+  using LanguageHmiCFImpl = GenericDtcImpl<DroLanguageHmiCF>;
+  namespace SampleInfo {
+    using LanguageHmi = GenericDtcSampleInfo<DroLanguageHmi>;
+    using LanguageHmiImpl = GenericDtcImplSampleInfo<DroLanguageHmi>;
+  }
+
+  // Topic ProjectDataManagement::LanguageXdu
+  using DroLanguageXdu = DDSGeneric::GenericDataReader<ProjectDataManagement::LanguageXdu>;
+  using LanguageXdu = GenericDtc<DroLanguageXdu>;
+  using LanguageXduImpl = GenericDtcImpl<DroLanguageXdu>;
+  using DroLanguageXduCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::LanguageXdu>;
+  using LanguageXduCF = GenericDtc<DroLanguageXduCF>;
+  using LanguageXduCFImpl = GenericDtcImpl<DroLanguageXduCF>;
+  namespace SampleInfo {
+    using LanguageXdu = GenericDtcSampleInfo<DroLanguageXdu>;
+    using LanguageXduImpl = GenericDtcImplSampleInfo<DroLanguageXdu>;
+  }
+
+  // Topic ProjectDataManagement::LoadType
+  using DroLoadType = DDSGeneric::GenericDataReader<ProjectDataManagement::LoadType>;
+  using LoadType = GenericDtc<DroLoadType>;
+  using LoadTypeImpl = GenericDtcImpl<DroLoadType>;
+  using DroLoadTypeCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::LoadType>;
+  using LoadTypeCF = GenericDtc<DroLoadTypeCF>;
+  using LoadTypeCFImpl = GenericDtcImpl<DroLoadTypeCF>;
+  namespace SampleInfo {
+    using LoadType = GenericDtcSampleInfo<DroLoadType>;
+    using LoadTypeImpl = GenericDtcImplSampleInfo<DroLoadType>;
+  }
+
+  // Topic ProjectDataManagement::NuclearPreset
+  using DroNuclearPreset = DDSGeneric::GenericDataReader<ProjectDataManagement::NuclearPreset>;
+  using NuclearPreset = GenericDtc<DroNuclearPreset>;
+  using NuclearPresetImpl = GenericDtcImpl<DroNuclearPreset>;
+  using DroNuclearPresetCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::NuclearPreset>;
+  using NuclearPresetCF = GenericDtc<DroNuclearPresetCF>;
+  using NuclearPresetCFImpl = GenericDtcImpl<DroNuclearPresetCF>;
+  namespace SampleInfo {
+    using NuclearPreset = GenericDtcSampleInfo<DroNuclearPreset>;
+    using NuclearPresetImpl = GenericDtcImplSampleInfo<DroNuclearPreset>;
+  }
+
+  // Topic ProjectDataManagement::RadioGroup
+  using DroRadioGroup = DDSGeneric::GenericDataReader<ProjectDataManagement::RadioGroup>;
+  using RadioGroup = GenericDtc<DroRadioGroup>;
+  using RadioGroupImpl = GenericDtcImpl<DroRadioGroup>;
+  using DroRadioGroupCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::RadioGroup>;
+  using RadioGroupCF = GenericDtc<DroRadioGroupCF>;
+  using RadioGroupCFImpl = GenericDtcImpl<DroRadioGroupCF>;
+  namespace SampleInfo {
+    using RadioGroup = GenericDtcSampleInfo<DroRadioGroup>;
+    using RadioGroupImpl = GenericDtcImplSampleInfo<DroRadioGroup>;
+  }
+
+  // Topic ProjectDataManagement::SanitationInjury
+  using DroSanitationInjury = DDSGeneric::GenericDataReader<ProjectDataManagement::SanitationInjury>;
+  using SanitationInjury = GenericDtc<DroSanitationInjury>;
+  using SanitationInjuryImpl = GenericDtcImpl<DroSanitationInjury>;
+  using DroSanitationInjuryCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::SanitationInjury>;
+  using SanitationInjuryCF = GenericDtc<DroSanitationInjuryCF>;
+  using SanitationInjuryCFImpl = GenericDtcImpl<DroSanitationInjuryCF>;
+  namespace SampleInfo {
+    using SanitationInjury = GenericDtcSampleInfo<DroSanitationInjury>;
+    using SanitationInjuryImpl = GenericDtcImplSampleInfo<DroSanitationInjury>;
+  }
+
+  // Topic ProjectDataManagement::SanitationInjuryKind
+  using DroSanitationInjuryKind = DDSGeneric::GenericDataReader<ProjectDataManagement::SanitationInjuryKind>;
+  using SanitationInjuryKind = GenericDtc<DroSanitationInjuryKind>;
+  using SanitationInjuryKindImpl = GenericDtcImpl<DroSanitationInjuryKind>;
+  using DroSanitationInjuryKindCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::SanitationInjuryKind>;
+  using SanitationInjuryKindCF = GenericDtc<DroSanitationInjuryKindCF>;
+  using SanitationInjuryKindCFImpl = GenericDtcImpl<DroSanitationInjuryKindCF>;
+  namespace SampleInfo {
+    using SanitationInjuryKind = GenericDtcSampleInfo<DroSanitationInjuryKind>;
+    using SanitationInjuryKindImpl = GenericDtcImplSampleInfo<DroSanitationInjuryKind>;
+  }
+
+  // Topic ProjectDataManagement::SanitationInjuryPlace1
+  using DroSanitationInjuryPlace1 = DDSGeneric::GenericDataReader<ProjectDataManagement::SanitationInjuryPlace1>;
+  using SanitationInjuryPlace1 = GenericDtc<DroSanitationInjuryPlace1>;
+  using SanitationInjuryPlace1Impl = GenericDtcImpl<DroSanitationInjuryPlace1>;
+  using DroSanitationInjuryPlace1CF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::SanitationInjuryPlace1>;
+  using SanitationInjuryPlace1CF = GenericDtc<DroSanitationInjuryPlace1CF>;
+  using SanitationInjuryPlace1CFImpl = GenericDtcImpl<DroSanitationInjuryPlace1CF>;
+  namespace SampleInfo {
+    using SanitationInjuryPlace1 = GenericDtcSampleInfo<DroSanitationInjuryPlace1>;
+    using SanitationInjuryPlace1Impl = GenericDtcImplSampleInfo<DroSanitationInjuryPlace1>;
+  }
+
+  // Topic ProjectDataManagement::SanitationInjuryPlace2
+  using DroSanitationInjuryPlace2 = DDSGeneric::GenericDataReader<ProjectDataManagement::SanitationInjuryPlace2>;
+  using SanitationInjuryPlace2 = GenericDtc<DroSanitationInjuryPlace2>;
+  using SanitationInjuryPlace2Impl = GenericDtcImpl<DroSanitationInjuryPlace2>;
+  using DroSanitationInjuryPlace2CF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::SanitationInjuryPlace2>;
+  using SanitationInjuryPlace2CF = GenericDtc<DroSanitationInjuryPlace2CF>;
+  using SanitationInjuryPlace2CFImpl = GenericDtcImpl<DroSanitationInjuryPlace2CF>;
+  namespace SampleInfo {
+    using SanitationInjuryPlace2 = GenericDtcSampleInfo<DroSanitationInjuryPlace2>;
+    using SanitationInjuryPlace2Impl = GenericDtcImplSampleInfo<DroSanitationInjuryPlace2>;
+  }
+
+  // Topic ProjectDataManagement::SanitationMaterial
+  using DroSanitationMaterial = DDSGeneric::GenericDataReader<ProjectDataManagement::SanitationMaterial>;
+  using SanitationMaterial = GenericDtc<DroSanitationMaterial>;
+  using SanitationMaterialImpl = GenericDtcImpl<DroSanitationMaterial>;
+  using DroSanitationMaterialCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::SanitationMaterial>;
+  using SanitationMaterialCF = GenericDtc<DroSanitationMaterialCF>;
+  using SanitationMaterialCFImpl = GenericDtcImpl<DroSanitationMaterialCF>;
+  namespace SampleInfo {
+    using SanitationMaterial = GenericDtcSampleInfo<DroSanitationMaterial>;
+    using SanitationMaterialImpl = GenericDtcImplSampleInfo<DroSanitationMaterial>;
+  }
+
+  // Topic ProjectDataManagement::SanitationProcedure
+  using DroSanitationProcedure = DDSGeneric::GenericDataReader<ProjectDataManagement::SanitationProcedure>;
+  using SanitationProcedure = GenericDtc<DroSanitationProcedure>;
+  using SanitationProcedureImpl = GenericDtcImpl<DroSanitationProcedure>;
+  using DroSanitationProcedureCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::SanitationProcedure>;
+  using SanitationProcedureCF = GenericDtc<DroSanitationProcedureCF>;
+  using SanitationProcedureCFImpl = GenericDtcImpl<DroSanitationProcedureCF>;
+  namespace SampleInfo {
+    using SanitationProcedure = GenericDtcSampleInfo<DroSanitationProcedure>;
+    using SanitationProcedureImpl = GenericDtcImplSampleInfo<DroSanitationProcedure>;
+  }
+
+  // Topic ProjectDataManagement::TargetSubType
+  using DroTargetSubType = DDSGeneric::GenericDataReader<ProjectDataManagement::TargetSubType>;
+  using TargetSubType = GenericDtc<DroTargetSubType>;
+  using TargetSubTypeImpl = GenericDtcImpl<DroTargetSubType>;
+  using DroTargetSubTypeCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::TargetSubType>;
+  using TargetSubTypeCF = GenericDtc<DroTargetSubTypeCF>;
+  using TargetSubTypeCFImpl = GenericDtcImpl<DroTargetSubTypeCF>;
+  namespace SampleInfo {
+    using TargetSubType = GenericDtcSampleInfo<DroTargetSubType>;
+    using TargetSubTypeImpl = GenericDtcImplSampleInfo<DroTargetSubType>;
+  }
+
+  // Topic ProjectDataManagement::TargetType
+  using DroTargetType = DDSGeneric::GenericDataReader<ProjectDataManagement::TargetType>;
+  using TargetType = GenericDtc<DroTargetType>;
+  using TargetTypeImpl = GenericDtcImpl<DroTargetType>;
+  using DroTargetTypeCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::TargetType>;
+  using TargetTypeCF = GenericDtc<DroTargetTypeCF>;
+  using TargetTypeCFImpl = GenericDtcImpl<DroTargetTypeCF>;
+  namespace SampleInfo {
+    using TargetType = GenericDtcSampleInfo<DroTargetType>;
+    using TargetTypeImpl = GenericDtcImplSampleInfo<DroTargetType>;
+  }
+
+  // Topic ProjectDataManagement::TargetTypeTargetSubType
+  using DroTargetTypeTargetSubType = DDSGeneric::GenericDataReader<ProjectDataManagement::TargetTypeTargetSubType>;
+  using TargetTypeTargetSubType = GenericDtc<DroTargetTypeTargetSubType>;
+  using TargetTypeTargetSubTypeImpl = GenericDtcImpl<DroTargetTypeTargetSubType>;
+  using DroTargetTypeTargetSubTypeCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::TargetTypeTargetSubType>;
+  using TargetTypeTargetSubTypeCF = GenericDtc<DroTargetTypeTargetSubTypeCF>;
+  using TargetTypeTargetSubTypeCFImpl = GenericDtcImpl<DroTargetTypeTargetSubTypeCF>;
+  namespace SampleInfo {
+    using TargetTypeTargetSubType = GenericDtcSampleInfo<DroTargetTypeTargetSubType>;
+    using TargetTypeTargetSubTypeImpl = GenericDtcImplSampleInfo<DroTargetTypeTargetSubType>;
+  }
+
+  // Topic ProjectDataManagement::TranslationBlob
+  using DroTranslationBlob = DDSGeneric::GenericDataReader<ProjectDataManagement::TranslationBlob>;
+  using TranslationBlob = GenericDtc<DroTranslationBlob>;
+  using TranslationBlobImpl = GenericDtcImpl<DroTranslationBlob>;
+  using DroTranslationBlobCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::TranslationBlob>;
+  using TranslationBlobCF = GenericDtc<DroTranslationBlobCF>;
+  using TranslationBlobCFImpl = GenericDtcImpl<DroTranslationBlobCF>;
+  namespace SampleInfo {
+    using TranslationBlob = GenericDtcSampleInfo<DroTranslationBlob>;
+    using TranslationBlobImpl = GenericDtcImplSampleInfo<DroTranslationBlob>;
+  }
+
+  // Topic ProjectDataManagement::VulnerabilityKind
+  using DroVulnerabilityKind = DDSGeneric::GenericDataReader<ProjectDataManagement::VulnerabilityKind>;
+  using VulnerabilityKind = GenericDtc<DroVulnerabilityKind>;
+  using VulnerabilityKindImpl = GenericDtcImpl<DroVulnerabilityKind>;
+  using DroVulnerabilityKindCF = DDSGeneric::GenericDataReaderContentFilter<ProjectDataManagement::VulnerabilityKind>;
+  using VulnerabilityKindCF = GenericDtc<DroVulnerabilityKindCF>;
+  using VulnerabilityKindCFImpl = GenericDtcImpl<DroVulnerabilityKindCF>;
+  namespace SampleInfo {
+    using VulnerabilityKind = GenericDtcSampleInfo<DroVulnerabilityKind>;
+    using VulnerabilityKindImpl = GenericDtcImplSampleInfo<DroVulnerabilityKind>;
+  }
+
+} // namespace DTC
+

forward-declarations/pdm_dts_types.h

@@ -0,0 +1,236 @@
+
+/**
+* DTS definitions
+*/
+
+// warning: this file is generated with command
+// Lts/Common/CodeGen/codegen_simple.py ALL Lts/Services/ProjectDataManagement/pdm_service.xml build/Lts/Services/ProjectDataManagement/
+// at Sun Sep  6 18:00:15 2026
+// it will be overwritten by next run - do not modify!
+
+#pragma once
+
+#include "pdm.hpp"
+
+/**
+ * Type definitions 
+ *  => DataWriterObjects (DWOs)
+ *  => DataTopicServers (DTSs)
+ */
+
+namespace DDSGeneric
+{
+template <typename T>
+class GenericDataWriter;
+}
+
+namespace DTS
+{
+   template<typename T> class GenericDts;
+   template<typename T> class GenericDtsImpl;
+
+  // Topic ProjectDataManagement::BiteComponentText
+  // Interface
+  using BiteComponentText = GenericDts<ProjectDataManagement::BiteComponentText>;
+  // Interface impl
+  using DwoBiteComponentText = DDSGeneric::GenericDataWriter<ProjectDataManagement::BiteComponentText>;
+  using BiteComponentTextImpl = GenericDtsImpl<DwoBiteComponentText>;
+
+  // Topic ProjectDataManagement::BuildingChargeEffect
+  // Interface
+  using BuildingChargeEffect = GenericDts<ProjectDataManagement::BuildingChargeEffect>;
+  // Interface impl
+  using DwoBuildingChargeEffect = DDSGeneric::GenericDataWriter<ProjectDataManagement::BuildingChargeEffect>;
+  using BuildingChargeEffectImpl = GenericDtsImpl<DwoBuildingChargeEffect>;
+
+  // Topic ProjectDataManagement::CanComponentString
+  // Interface
+  using CanComponentString = GenericDts<ProjectDataManagement::CanComponentString>;
+  // Interface impl
+  using DwoCanComponentString = DDSGeneric::GenericDataWriter<ProjectDataManagement::CanComponentString>;
+  using CanComponentStringImpl = GenericDtsImpl<DwoCanComponentString>;
+
+  // Topic ProjectDataManagement::ChargeType
+  // Interface
+  using ChargeType = GenericDts<ProjectDataManagement::ChargeType>;
+  // Interface impl
+  using DwoChargeType = DDSGeneric::GenericDataWriter<ProjectDataManagement::ChargeType>;
+  using ChargeTypeImpl = GenericDtsImpl<DwoChargeType>;
+
+  // Topic ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction
+  // Interface
+  using ChargeTypeIgniterTypeIgniterFunction = GenericDts<ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction>;
+  // Interface impl
+  using DwoChargeTypeIgniterTypeIgniterFunction = DDSGeneric::GenericDataWriter<ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction>;
+  using ChargeTypeIgniterTypeIgniterFunctionImpl = GenericDtsImpl<DwoChargeTypeIgniterTypeIgniterFunction>;
+
+  // Topic ProjectDataManagement::ChargeTypeLoadType
+  // Interface
+  using ChargeTypeLoadType = GenericDts<ProjectDataManagement::ChargeTypeLoadType>;
+  // Interface impl
+  using DwoChargeTypeLoadType = DDSGeneric::GenericDataWriter<ProjectDataManagement::ChargeTypeLoadType>;
+  using ChargeTypeLoadTypeImpl = GenericDtsImpl<DwoChargeTypeLoadType>;
+
+  // Topic ProjectDataManagement::EquipmentSystemEventFilter
+  // Interface
+  using EquipmentSystemEventFilter = GenericDts<ProjectDataManagement::EquipmentSystemEventFilter>;
+  // Interface impl
+  using DwoEquipmentSystemEventFilter = DDSGeneric::GenericDataWriter<ProjectDataManagement::EquipmentSystemEventFilter>;
+  using EquipmentSystemEventFilterImpl = GenericDtsImpl<DwoEquipmentSystemEventFilter>;
+
+  // Topic ProjectDataManagement::EventFilterHgrMineSearch
+  // Interface
+  using EventFilterHgrMineSearch = GenericDts<ProjectDataManagement::EventFilterHgrMineSearch>;
+  // Interface impl
+  using DwoEventFilterHgrMineSearch = DDSGeneric::GenericDataWriter<ProjectDataManagement::EventFilterHgrMineSearch>;
+  using EventFilterHgrMineSearchImpl = GenericDtsImpl<DwoEventFilterHgrMineSearch>;
+
+  // Topic ProjectDataManagement::FirePurpose
+  // Interface
+  using FirePurpose = GenericDts<ProjectDataManagement::FirePurpose>;
+  // Interface impl
+  using DwoFirePurpose = DDSGeneric::GenericDataWriter<ProjectDataManagement::FirePurpose>;
+  using FirePurposeImpl = GenericDtsImpl<DwoFirePurpose>;
+
+  // Topic ProjectDataManagement::GearType
+  // Interface
+  using GearType = GenericDts<ProjectDataManagement::GearType>;
+  // Interface impl
+  using DwoGearType = DDSGeneric::GenericDataWriter<ProjectDataManagement::GearType>;
+  using GearTypeImpl = GenericDtsImpl<DwoGearType>;
+
+  // Topic ProjectDataManagement::GearTypeChargeType
+  // Interface
+  using GearTypeChargeType = GenericDts<ProjectDataManagement::GearTypeChargeType>;
+  // Interface impl
+  using DwoGearTypeChargeType = DDSGeneric::GenericDataWriter<ProjectDataManagement::GearTypeChargeType>;
+  using GearTypeChargeTypeImpl = GenericDtsImpl<DwoGearTypeChargeType>;
+
+  // Topic ProjectDataManagement::IgniterFunction
+  // Interface
+  using IgniterFunction = GenericDts<ProjectDataManagement::IgniterFunction>;
+  // Interface impl
+  using DwoIgniterFunction = DDSGeneric::GenericDataWriter<ProjectDataManagement::IgniterFunction>;
+  using IgniterFunctionImpl = GenericDtsImpl<DwoIgniterFunction>;
+
+  // Topic ProjectDataManagement::IgniterType
+  // Interface
+  using IgniterType = GenericDts<ProjectDataManagement::IgniterType>;
+  // Interface impl
+  using DwoIgniterType = DDSGeneric::GenericDataWriter<ProjectDataManagement::IgniterType>;
+  using IgniterTypeImpl = GenericDtsImpl<DwoIgniterType>;
+
+  // Topic ProjectDataManagement::LanguageHmi
+  // Interface
+  using LanguageHmi = GenericDts<ProjectDataManagement::LanguageHmi>;
+  // Interface impl
+  using DwoLanguageHmi = DDSGeneric::GenericDataWriter<ProjectDataManagement::LanguageHmi>;
+  using LanguageHmiImpl = GenericDtsImpl<DwoLanguageHmi>;
+
+  // Topic ProjectDataManagement::LanguageXdu
+  // Interface
+  using LanguageXdu = GenericDts<ProjectDataManagement::LanguageXdu>;
+  // Interface impl
+  using DwoLanguageXdu = DDSGeneric::GenericDataWriter<ProjectDataManagement::LanguageXdu>;
+  using LanguageXduImpl = GenericDtsImpl<DwoLanguageXdu>;
+
+  // Topic ProjectDataManagement::LoadType
+  // Interface
+  using LoadType = GenericDts<ProjectDataManagement::LoadType>;
+  // Interface impl
+  using DwoLoadType = DDSGeneric::GenericDataWriter<ProjectDataManagement::LoadType>;
+  using LoadTypeImpl = GenericDtsImpl<DwoLoadType>;
+
+  // Topic ProjectDataManagement::NuclearPreset
+  // Interface
+  using NuclearPreset = GenericDts<ProjectDataManagement::NuclearPreset>;
+  // Interface impl
+  using DwoNuclearPreset = DDSGeneric::GenericDataWriter<ProjectDataManagement::NuclearPreset>;
+  using NuclearPresetImpl = GenericDtsImpl<DwoNuclearPreset>;
+
+  // Topic ProjectDataManagement::RadioGroup
+  // Interface
+  using RadioGroup = GenericDts<ProjectDataManagement::RadioGroup>;
+  // Interface impl
+  using DwoRadioGroup = DDSGeneric::GenericDataWriter<ProjectDataManagement::RadioGroup>;
+  using RadioGroupImpl = GenericDtsImpl<DwoRadioGroup>;
+
+  // Topic ProjectDataManagement::SanitationInjury
+  // Interface
+  using SanitationInjury = GenericDts<ProjectDataManagement::SanitationInjury>;
+  // Interface impl
+  using DwoSanitationInjury = DDSGeneric::GenericDataWriter<ProjectDataManagement::SanitationInjury>;
+  using SanitationInjuryImpl = GenericDtsImpl<DwoSanitationInjury>;
+
+  // Topic ProjectDataManagement::SanitationInjuryKind
+  // Interface
+  using SanitationInjuryKind = GenericDts<ProjectDataManagement::SanitationInjuryKind>;
+  // Interface impl
+  using DwoSanitationInjuryKind = DDSGeneric::GenericDataWriter<ProjectDataManagement::SanitationInjuryKind>;
+  using SanitationInjuryKindImpl = GenericDtsImpl<DwoSanitationInjuryKind>;
+
+  // Topic ProjectDataManagement::SanitationInjuryPlace1
+  // Interface
+  using SanitationInjuryPlace1 = GenericDts<ProjectDataManagement::SanitationInjuryPlace1>;
+  // Interface impl
+  using DwoSanitationInjuryPlace1 = DDSGeneric::GenericDataWriter<ProjectDataManagement::SanitationInjuryPlace1>;
+  using SanitationInjuryPlace1Impl = GenericDtsImpl<DwoSanitationInjuryPlace1>;
+
+  // Topic ProjectDataManagement::SanitationInjuryPlace2
+  // Interface
+  using SanitationInjuryPlace2 = GenericDts<ProjectDataManagement::SanitationInjuryPlace2>;
+  // Interface impl
+  using DwoSanitationInjuryPlace2 = DDSGeneric::GenericDataWriter<ProjectDataManagement::SanitationInjuryPlace2>;
+  using SanitationInjuryPlace2Impl = GenericDtsImpl<DwoSanitationInjuryPlace2>;
+
+  // Topic ProjectDataManagement::SanitationMaterial
+  // Interface
+  using SanitationMaterial = GenericDts<ProjectDataManagement::SanitationMaterial>;
+  // Interface impl
+  using DwoSanitationMaterial = DDSGeneric::GenericDataWriter<ProjectDataManagement::SanitationMaterial>;
+  using SanitationMaterialImpl = GenericDtsImpl<DwoSanitationMaterial>;
+
+  // Topic ProjectDataManagement::SanitationProcedure
+  // Interface
+  using SanitationProcedure = GenericDts<ProjectDataManagement::SanitationProcedure>;
+  // Interface impl
+  using DwoSanitationProcedure = DDSGeneric::GenericDataWriter<ProjectDataManagement::SanitationProcedure>;
+  using SanitationProcedureImpl = GenericDtsImpl<DwoSanitationProcedure>;
+
+  // Topic ProjectDataManagement::TargetSubType
+  // Interface
+  using TargetSubType = GenericDts<ProjectDataManagement::TargetSubType>;
+  // Interface impl
+  using DwoTargetSubType = DDSGeneric::GenericDataWriter<ProjectDataManagement::TargetSubType>;
+  using TargetSubTypeImpl = GenericDtsImpl<DwoTargetSubType>;
+
+  // Topic ProjectDataManagement::TargetType
+  // Interface
+  using TargetType = GenericDts<ProjectDataManagement::TargetType>;
+  // Interface impl
+  using DwoTargetType = DDSGeneric::GenericDataWriter<ProjectDataManagement::TargetType>;
+  using TargetTypeImpl = GenericDtsImpl<DwoTargetType>;
+
+  // Topic ProjectDataManagement::TargetTypeTargetSubType
+  // Interface
+  using TargetTypeTargetSubType = GenericDts<ProjectDataManagement::TargetTypeTargetSubType>;
+  // Interface impl
+  using DwoTargetTypeTargetSubType = DDSGeneric::GenericDataWriter<ProjectDataManagement::TargetTypeTargetSubType>;
+  using TargetTypeTargetSubTypeImpl = GenericDtsImpl<DwoTargetTypeTargetSubType>;
+
+  // Topic ProjectDataManagement::TranslationBlob
+  // Interface
+  using TranslationBlob = GenericDts<ProjectDataManagement::TranslationBlob>;
+  // Interface impl
+  using DwoTranslationBlob = DDSGeneric::GenericDataWriter<ProjectDataManagement::TranslationBlob>;
+  using TranslationBlobImpl = GenericDtsImpl<DwoTranslationBlob>;
+
+  // Topic ProjectDataManagement::VulnerabilityKind
+  // Interface
+  using VulnerabilityKind = GenericDts<ProjectDataManagement::VulnerabilityKind>;
+  // Interface impl
+  using DwoVulnerabilityKind = DDSGeneric::GenericDataWriter<ProjectDataManagement::VulnerabilityKind>;
+  using VulnerabilityKindImpl = GenericDtsImpl<DwoVulnerabilityKind>;
+
+} // namespace DTS
+

forward-declarations/pdm_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace ProjectDataManagement
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace ProjectDataManagement

forward-declarations/pdm_ftc_types.h

@@ -0,0 +1,64 @@
+
+/**
+* FTC definitions
+*/
+
+// warning: this file is generated with command
+// Lts/Common/CodeGen/codegen_simple.py ALL Lts/Services/ProjectDataManagement/pdm_service.xml build/Lts/Services/ProjectDataManagement/
+// at Sun Sep  6 18:00:15 2026
+// it will be overwritten by next run - do not modify!
+
+#pragma once
+
+#include "pdm.hpp"
+
+namespace FTC
+{
+template <typename REQ, typename REP, typename DUMMY> class GenericFtcImpl;
+template<typename GENERIC_FTC> struct TopicNames;
+}
+namespace ProjectDataManagement
+{
+  // TypeDefinitions for Replies that are not implemented => using Core::FunctionReply
+  using InsertUpdateTranslationReply = Core::FunctionReply;
+  using UpdateChargeNamesReply = Core::FunctionReply;
+  using UpdateChargeTypeRequest = ProjectDataManagement::ChargeType;
+  using UpdateChargeTypeReply = Core::FunctionReply;
+} // namespace ProjectDataManagement
+
+
+namespace FTC
+{
+  // TypeDefinitions for GenericFtcImpl
+  class InsertUpdateTranslationTemplateHelperDummy;
+  using InsertUpdateTranslation = GenericFtcImpl<ProjectDataManagement::InsertUpdateTranslationRequest, ProjectDataManagement::InsertUpdateTranslationReply, InsertUpdateTranslationTemplateHelperDummy>;
+  template<> struct TopicNames<InsertUpdateTranslation>  {
+    static constexpr const char *functionTopicName()    { return "InsertUpdateTranslation"; }
+    static constexpr const char *replyTopicName()       { return "LTS_InsertUpdateTranslationReply"; }
+    static constexpr const char *replyTopicTypeName()   { return "ProjectDataManagement::InsertUpdateTranslationReply"; }
+    static constexpr const char *requestTopicName()     { return "LTS_InsertUpdateTranslationRequest"; }
+    static constexpr const char *requestTopicTypeName() { return "ProjectDataManagement::InsertUpdateTranslationRequest"; }
+  };
+
+  class UpdateChargeNamesTemplateHelperDummy;
+  using UpdateChargeNames = GenericFtcImpl<ProjectDataManagement::UpdateChargeNamesRequest, ProjectDataManagement::UpdateChargeNamesReply, UpdateChargeNamesTemplateHelperDummy>;
+  template<> struct TopicNames<UpdateChargeNames>  {
+    static constexpr const char *functionTopicName()    { return "UpdateChargeNames"; }
+    static constexpr const char *replyTopicName()       { return "LTS_UpdateChargeNamesReply"; }
+    static constexpr const char *replyTopicTypeName()   { return "ProjectDataManagement::UpdateChargeNamesReply"; }
+    static constexpr const char *requestTopicName()     { return "LTS_UpdateChargeNamesRequest"; }
+    static constexpr const char *requestTopicTypeName() { return "ProjectDataManagement::UpdateChargeNamesRequest"; }
+  };
+
+  class UpdateChargeTypeTemplateHelperDummy;
+  using UpdateChargeType = GenericFtcImpl<ProjectDataManagement::ChargeType, ProjectDataManagement::UpdateChargeTypeReply, UpdateChargeTypeTemplateHelperDummy>;
+  template<> struct TopicNames<UpdateChargeType>  {
+    static constexpr const char *functionTopicName()    { return "UpdateChargeType"; }
+    static constexpr const char *replyTopicName()       { return "LTS_UpdateChargeTypeReply"; }
+    static constexpr const char *replyTopicTypeName()   { return "ProjectDataManagement::UpdateChargeTypeReply"; }
+    static constexpr const char *requestTopicName()     { return "LTS_UpdateChargeTypeRequest"; }
+    static constexpr const char *requestTopicTypeName() { return "ProjectDataManagement::UpdateChargeTypeRequest"; }
+  };
+
+} // namespace FTC
+

forward-declarations/pdm_fts_types.h

@@ -0,0 +1,64 @@
+
+/**
+* FTS definitions
+*/
+
+// warning: this file is generated with command
+// Lts/Common/CodeGen/codegen_simple.py ALL Lts/Services/ProjectDataManagement/pdm_service.xml build/Lts/Services/ProjectDataManagement/
+// at Sun Sep  6 18:00:15 2026
+// it will be overwritten by next run - do not modify!
+
+#pragma once
+
+#include "pdm.hpp"
+
+namespace FTS
+{
+template <typename REQ, typename REP, typename DUMMY> class GenericFtsImpl;
+template<typename GENERIC_FTS> struct TopicNames;
+}
+namespace ProjectDataManagement
+{
+  // TypeDefinitions for Replies that are not implemented => using Core::FunctionReply
+  using InsertUpdateTranslationReply = Core::FunctionReply;
+  using UpdateChargeNamesReply = Core::FunctionReply;
+  using UpdateChargeTypeRequest = ProjectDataManagement::ChargeType;
+  using UpdateChargeTypeReply = Core::FunctionReply;
+} // namespace ProjectDataManagement
+
+
+namespace FTS
+{
+  // TypeDefinitions for GenericFtsImpl
+  class InsertUpdateTranslationTemplateHelperDummy;
+  using InsertUpdateTranslation = GenericFtsImpl<ProjectDataManagement::InsertUpdateTranslationRequest, ProjectDataManagement::InsertUpdateTranslationReply, InsertUpdateTranslationTemplateHelperDummy>;
+  template<> struct TopicNames<InsertUpdateTranslation>  {
+    static constexpr const char *functionTopicName()    { return "InsertUpdateTranslation"; }
+    static constexpr const char *replyTopicName()       { return "LTS_InsertUpdateTranslationReply"; }
+    static constexpr const char *replyTopicTypeName()   { return "ProjectDataManagement::InsertUpdateTranslationReply"; }
+    static constexpr const char *requestTopicName()     { return "LTS_InsertUpdateTranslationRequest"; }
+    static constexpr const char *requestTopicTypeName() { return "ProjectDataManagement::InsertUpdateTranslationRequest"; }
+  };
+
+  class UpdateChargeNamesTemplateHelperDummy;
+  using UpdateChargeNames = GenericFtsImpl<ProjectDataManagement::UpdateChargeNamesRequest, ProjectDataManagement::UpdateChargeNamesReply, UpdateChargeNamesTemplateHelperDummy>;
+  template<> struct TopicNames<UpdateChargeNames>  {
+    static constexpr const char *functionTopicName()    { return "UpdateChargeNames"; }
+    static constexpr const char *replyTopicName()       { return "LTS_UpdateChargeNamesReply"; }
+    static constexpr const char *replyTopicTypeName()   { return "ProjectDataManagement::UpdateChargeNamesReply"; }
+    static constexpr const char *requestTopicName()     { return "LTS_UpdateChargeNamesRequest"; }
+    static constexpr const char *requestTopicTypeName() { return "ProjectDataManagement::UpdateChargeNamesRequest"; }
+  };
+
+  class UpdateChargeTypeTemplateHelperDummy;
+  using UpdateChargeType = GenericFtsImpl<ProjectDataManagement::ChargeType, ProjectDataManagement::UpdateChargeTypeReply, UpdateChargeTypeTemplateHelperDummy>;
+  template<> struct TopicNames<UpdateChargeType>  {
+    static constexpr const char *functionTopicName()    { return "UpdateChargeType"; }
+    static constexpr const char *replyTopicName()       { return "LTS_UpdateChargeTypeReply"; }
+    static constexpr const char *replyTopicTypeName()   { return "ProjectDataManagement::UpdateChargeTypeReply"; }
+    static constexpr const char *requestTopicName()     { return "LTS_UpdateChargeTypeRequest"; }
+    static constexpr const char *requestTopicTypeName() { return "ProjectDataManagement::UpdateChargeTypeRequest"; }
+  };
+
+} // namespace FTS
+

forward-declarations/pdm_operator_rights.h

@@ -0,0 +1,34 @@
+
+/**
+* Operator Rights definitions
+*/
+
+// warning: this file is generated with command
+// Lts/Common/CodeGen/codegen_simple.py ALL Lts/Services/ProjectDataManagement/pdm_service.xml build/Lts/Services/ProjectDataManagement/
+// at Sun Sep  6 18:00:15 2026
+// it will be overwritten by next run - do not modify!
+
+#pragma once
+
+namespace ProjectDataManagement 
+{
+  static const int Offset = 29; 
+}
+
+namespace OperatorRights
+{
+enum Charges
+{
+  ChargeVisibilityEdit = 0x1d010001,
+};
+
+enum Groups_ProjectDataManagement
+{
+  GroupChargeVisibility = 0x1d010000,
+};
+
+enum Plugins_ProjectDataManagement
+{
+  PluginCharges = 0x1d010000,
+};
+}  // namespace OperatorRights

forward-declarations/ppm_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace ParticipantManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace ParticipantManagement

forward-declarations/ppm_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace ParticipantManagement
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace ParticipantManagement

forward-declarations/pre_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace PresentationManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace PresentationManagement

forward-declarations/rep_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace ReportManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace ReportManagement

forward-declarations/rep_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace ReportManagement
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace ReportManagement

forward-declarations/scm_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace ServiceManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace ServiceManagement

forward-declarations/skl_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace Skeleton
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace Skeleton

forward-declarations/som_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace SoundManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace SoundManagement

forward-declarations/srm_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace SituationReplayManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace SituationReplayManagement

forward-declarations/srp_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace SituationReplay
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace SituationReplay

forward-declarations/srp_enums.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+namespace SituationReplay
+{
+// Placeholder enums - werden durch echte DDS-Typen ersetzt
+enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
+
+enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
+
+struct UnitSymbolPosition
+{
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+} // namespace SituationReplay

forward-declarations/tab_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace TrainingAreaBase
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace TrainingAreaBase

forward-declarations/taboc_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace TrainingAreaBaseOC
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace TrainingAreaBaseOC

forward-declarations/tgt_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace TargetManagement
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace TargetManagement

forward-declarations/whg_dtc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace WarehouseGuez
+{
+namespace Interface
+{
+class Dtc;
+class Ftc;
+} // namespace Interface
+} // namespace WarehouseGuez

prompts/physically-move-forward-decl-files.prompt.md

@@ -0,0 +1,95 @@
+```text
+Setze die Qt5->Qt6-Migration fort und bearbeite strikt nur die ./files.txt aufgelisteten Stub-Dateien im Qt6-Baum.
+
+Ausgangslage:
+- die ./files.txt aufgelisteten Dateien wurden während der Migration als STUBS erzeugt
+- die Migration ist noch nicht abgeschlossen
+- /workspace/app/Dockerfile ist der Migrationscontainer
+- /workspace/qt-migration-legatus/qt6-after/qt6-migrated-legatus/docker_build.sh ist der Validierungscontainer nach einem Migrationsschritt
+
+Ziel:
+- verschiebe die ./files.txt aufgelisteten Stub-/Forward-Declaration-Dateien physisch in ein gemeinsames Verzeichnis:
+  - /workspace/qt-migration-legatus/qt6-after/qt6-migrated-legatus/forward-declarations
+- passe danach die direkt betroffenen Includes und CMake-Build-Skripte minimal so an, dass ausschließlich diese neue physische Ablage verwendet wird
+
+Wichtige Klarstellung:
+- es geht ausdrücklich um **physisches Verschieben**
+- keine Wrapper-Header
+- keine Weiterleitungs-Header
+- keine Kopien
+- keine Duplikate
+- keine parallele Alt-/Neu-Struktur
+- keine Kompatibilitätslayer
+- keine Symlinks
+- kein Belassen der bisherigen Stub-Dateien an den alten Orten
+
+Harte Regeln:
+- nur die ./files.txt aufgelisteten Stub-Dateien bearbeiten
+- keine Refactorings
+- keine opportunistischen Fixes
+- keine fachlogischen Änderungen
+- keine Änderungen im Legacy-Tree
+- keine neuen Stubs erzeugen
+- keine neuen Placeholder-Dateien erzeugen
+- keine Scheinlösung über zusätzliche Include-Pfade, die alte und neue Orte gleichzeitig sichtbar machen
+- Build und Includes sollen deterministisch nur noch gegen die neue Struktur arbeiten
+
+Pflichtanalyse:
+- prüfe jede aufgelistete Datei darauf, ob sie tatsächlich ein Stub-/Forward-Declaration-Artefakt ist
+- falls einzelne gelistete Dateien doch keine solchen Artefakte sind, verschiebe sie nicht blind, sondern dokumentiere sie als Ausnahmen
+- identifiziere Redundanzen und Mehrfachablagen
+- bestimme die minimal nötigen Include-Anpassungen nach dem physischen Verschieben
+- bestimme die minimal nötigen CMake-Anpassungen nach dem physischen Verschieben
+
+Pflichtumsetzung:
+- lege an:
+  - /workspace/qt-migration-legatus/qt6-after/qt6-migrated-legatus/forward-declarations
+- verschiebe die betroffenen Dateien physisch dorthin
+- bereinige die alten Pfade so, dass keine alten Stub-Dateien zurückbleiben
+- passe alle direkt betroffenen `#include`-Stellen minimal an
+- passe alle direkt betroffenen `CMakeLists.txt` / cmake-Include-Pfade minimal an
+- stelle sicher, dass die neue Struktur im Build korrekt und eindeutig referenziert wird
+
+Strikte Include-/CMake-Regeln:
+- bevorzuge zielbezogene Include-Pfade mit `target_include_directories(...)`
+- vermeide globale `include_directories(...)`, außer wenn das bestehende Buildsystem es an genau dieser Stelle zwingend verlangt
+- füge nicht gleichzeitig alte und neue Stub-Verzeichnisse in Include-Pfade ein
+- keine Workarounds durch künstliche Suchreihenfolgen
+- keine Pfadverdopplungen
+- keine implizite Altpfad-Kompatibilität
+- nur direkt betroffene Build-Skripte ändern
+
+Validierung:
+- nutze /workspace/qt-migration-legatus/qt6-after/qt6-migrated-legatus/docker_build.sh als Validierungsweg
+- passe das Script nur an, wenn für diese Aufgabe zwingend nötig
+- führe mindestens Configure + Build im Docker-Kontext aus
+- prüfe, dass die Builds die Dateien tatsächlich aus `forward-declarations` konsumieren
+- prüfe, dass kein Build-Erfolg mehr von den alten Pfaden abhängt
+- falls sinnvoll, nutze gezielte Target-Builds zusätzlich zur Gesamtvalidierung
+
+Erfolgskriterien:
+- die betroffenen Stub-/Forward-Declaration-Dateien wurden physisch nach
+  - /workspace/qt-migration-legatus/qt6-after/qt6-migrated-legatus/forward-declarations
+  verschoben
+- die alten Stub-Dateien liegen nicht mehr an den bisherigen Pfaden
+- Includes und CMake-Skripte sind minimal angepasst
+- der Build referenziert deterministisch die neue Struktur
+- keine Wrapper-/Redirect-/Kompatibilitätsheader
+- keine Duplikate
+- keine unnötigen Moduländerungen
+- keine vorgetäuschte Validierung
+
+Wenn etwas nicht sauber möglich ist:
+- nicht mit Wrappern oder Kopien ausweichen
+- nicht stillschweigend beide Strukturen parallel behalten
+- als teilweise validiert oder blockiert melden
+- exakten technischen Blocker benennen
+
+Abschlussbericht nur kurz:
+- validiert, teilweise validiert oder blockiert
+- physisch verschobene Dateien
+- geänderte Include-Stellen
+- geänderte CMake-Dateien
+- exakte Docker-Kommandos
+- verbleibende Blocker oder Risiken
+```