/*
WARNING: THIS FILE IS AUTO-GENERATED. DO NOT MODIFY.

This file was generated from pdm.idl
using RTI Code Generator (rtiddsgen) version 4.7.0.
The rtiddsgen tool is part of the RTI Connext DDS distribution.
For more information, type 'rtiddsgen -help' at a command shell
or consult the Code Generator User's Manual.
*/

#ifndef pdm_713756303_hpp
#define pdm_713756303_hpp

#include <iosfwd>

#if defined(NDDS_USER_DLL_EXPORT) && defined(RTI_WIN32)
#undef RTIUSERDllExport
#define RTIUSERDllExport __declspec(dllexport)
#endif

#if !defined(RTI_WIN32) && defined(NDDS_USER_SYMBOL_EXPORT)
#undef RTIUSERDllExport
#define RTIUSERDllExport __attribute__((visibility("default")))
#endif

#include "dds/core/SafeEnumeration.hpp"
#include "dds/core/String.hpp"
#include "dds/core/array.hpp"
#include "dds/core/vector.hpp"
#include "dds/core/External.hpp"
#include "rti/core/LongDouble.hpp"
#include "rti/core/Pointer.hpp"
#include "rti/core/array.hpp"
#include "rti/topic/TopicTraits.hpp"

#include "omg/types/string_view.hpp"

#include "omg/types/sequence.hpp"
#include "omg/types/optional.hpp"

#ifndef NDDS_STANDALONE_TYPE
#include "cdr/cdr_typeCode.h"
#include "dds/domain/DomainParticipant.hpp"
#include "dds/topic/TopicTraits.hpp"
#include "dds/core/xtypes/DynamicType.hpp"
#include "dds/core/xtypes/StructType.hpp"
#include "dds/core/xtypes/UnionType.hpp"
#include "dds/core/xtypes/EnumType.hpp"
#include "dds/core/xtypes/AliasType.hpp"
#include "rti/util/StreamFlagSaver.hpp"
#include "rti/domain/PluginSupport.hpp"
#endif

#if defined(NDDS_USER_DLL_EXPORT) || defined(NDDS_USER_SYMBOL_EXPORT)
#undef RTIUSERDllExport
#define RTIUSERDllExport
#endif

#if defined(NDDS_USER_DLL_EXPORT) && defined(RTI_WIN32)
#undef NDDSUSERDllExport
#define NDDSUSERDllExport __declspec(dllexport)
#endif

#if !defined(RTI_WIN32) && defined(NDDS_USER_SYMBOL_EXPORT)
#undef NDDSUSERDllExport
#define NDDSUSERDllExport __attribute__((visibility("default")))
#endif

#include <ProjectDataManagement/pdm_export.h> // #define NDDSUSERDllExport for linux
#include "pdm_enums.hpp"
#if defined(NDDS_USER_DLL_EXPORT) || defined(NDDS_USER_SYMBOL_EXPORT)
#undef NDDSUSERDllExport
#define NDDSUSERDllExport
#endif
#include "pdm_enums.hpp"
#if defined(NDDS_USER_DLL_EXPORT) && defined(RTI_WIN32)
#undef NDDSUSERDllExport
#define NDDSUSERDllExport __declspec(dllexport)
#endif

#if !defined(RTI_WIN32) && defined(NDDS_USER_SYMBOL_EXPORT)
#undef NDDSUSERDllExport
#define NDDSUSERDllExport __attribute__((visibility("default")))
#endif
#include </workspace/qt-migration-legatus/qt6-after/qt6-migrated-legatus/build4/Lts/DDS/Core/core.hpp>
#if defined(NDDS_USER_DLL_EXPORT) || defined(NDDS_USER_SYMBOL_EXPORT)
#undef NDDSUSERDllExport
#define NDDSUSERDllExport
#endif
#include "/workspace/qt-migration-legatus/qt6-after/qt6-migrated-legatus/build4/Lts/DDS/Core/core.hpp"
#if defined(NDDS_USER_DLL_EXPORT) && defined(RTI_WIN32)
#undef NDDSUSERDllExport
#define NDDSUSERDllExport __declspec(dllexport)
#endif

#if !defined(RTI_WIN32) && defined(NDDS_USER_SYMBOL_EXPORT)
#undef NDDSUSERDllExport
#define NDDSUSERDllExport __attribute__((visibility("default")))
#endif
namespace ProjectDataManagement {

    struct NDDSUSERDllExport PdmBase {
        int32_t id {};

        PdmBase();

        explicit PdmBase(int32_t id_);

    };

    NDDSUSERDllExport bool operator == (const PdmBase& a, const PdmBase& b);
    NDDSUSERDllExport bool operator != (const PdmBase& a, const PdmBase& b);
    NDDSUSERDllExport void swap(PdmBase& a, PdmBase& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const PdmBase& sample);

    struct NDDSUSERDllExport PdmBaseName
    : public ::ProjectDataManagement::PdmBase {
        std::string name {};

        PdmBaseName();

        explicit PdmBaseName(int32_t id_,const ::omg::types::string_view& name_);

    };

    NDDSUSERDllExport bool operator == (const PdmBaseName& a, const PdmBaseName& b);
    NDDSUSERDllExport bool operator != (const PdmBaseName& a, const PdmBaseName& b);
    NDDSUSERDllExport void swap(PdmBaseName& a, PdmBaseName& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const PdmBaseName& sample);

    struct NDDSUSERDllExport BiteComponentText
    : public ::ProjectDataManagement::PdmBaseName {
        int32_t canDeviceId {};
        int32_t subDeviceId {};
        int32_t errorNumber {};

        BiteComponentText();

        BiteComponentText(int32_t id_,const ::omg::types::string_view& name_,int32_t canDeviceId_,int32_t subDeviceId_,int32_t errorNumber_);

    };

    NDDSUSERDllExport bool operator == (const BiteComponentText& a, const BiteComponentText& b);
    NDDSUSERDllExport bool operator != (const BiteComponentText& a, const BiteComponentText& b);
    NDDSUSERDllExport void swap(BiteComponentText& a, BiteComponentText& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const BiteComponentText& sample);

    struct NDDSUSERDllExport BuildingChargeEffect
    : public ::ProjectDataManagement::PdmBase {
        int32_t chargeTypeId {};
        int32_t destructiveFactor {};
        int32_t penetrationFactor {};
        int32_t hitSound {};
        bool difcueLight {};
        bool difcuePyro {};

        BuildingChargeEffect();

        BuildingChargeEffect(int32_t id_,int32_t chargeTypeId_,int32_t destructiveFactor_,int32_t penetrationFactor_,int32_t hitSound_,bool difcueLight_,bool difcuePyro_);

    };

    NDDSUSERDllExport bool operator == (const BuildingChargeEffect& a, const BuildingChargeEffect& b);
    NDDSUSERDllExport bool operator != (const BuildingChargeEffect& a, const BuildingChargeEffect& b);
    NDDSUSERDllExport void swap(BuildingChargeEffect& a, BuildingChargeEffect& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const BuildingChargeEffect& sample);

    struct NDDSUSERDllExport CanComponentString
    : public ::ProjectDataManagement::PdmBaseName {
        int64_t pdm_bitMask {};
        int32_t canDeviceId {};
        int32_t subDeviceId {};

        CanComponentString();

        CanComponentString(int32_t id_,const ::omg::types::string_view& name_,int64_t pdm_bitMask_,int32_t canDeviceId_,int32_t subDeviceId_);

    };

    NDDSUSERDllExport bool operator == (const CanComponentString& a, const CanComponentString& b);
    NDDSUSERDllExport bool operator != (const CanComponentString& a, const CanComponentString& b);
    NDDSUSERDllExport void swap(CanComponentString& a, CanComponentString& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const CanComponentString& sample);

    struct NDDSUSERDllExport CasEffect {
        ::ProjectDataManagement::SeverityType severityType {};
        int32_t iedClass {};
        int32_t impactRadius {};

        CasEffect();

        CasEffect(const ::ProjectDataManagement::SeverityType& severityType_,int32_t iedClass_,int32_t impactRadius_);

    };

    NDDSUSERDllExport bool operator == (const CasEffect& a, const CasEffect& b);
    NDDSUSERDllExport bool operator != (const CasEffect& a, const CasEffect& b);
    NDDSUSERDllExport void swap(CasEffect& a, CasEffect& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const CasEffect& sample);

    struct NDDSUSERDllExport ChargeType
    : public ::ProjectDataManagement::PdmBaseName {
        std::string shortName {};
        std::string predefinedName {};
        std::string disEntity {};
        std::string properties {};
        int32_t legacyId {};

        ChargeType();

        ChargeType(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& shortName_,const ::omg::types::string_view& predefinedName_,const ::omg::types::string_view& disEntity_,const ::omg::types::string_view& properties_,int32_t legacyId_);

    };

    NDDSUSERDllExport bool operator == (const ChargeType& a, const ChargeType& b);
    NDDSUSERDllExport bool operator != (const ChargeType& a, const ChargeType& b);
    NDDSUSERDllExport void swap(ChargeType& a, ChargeType& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const ChargeType& sample);

    struct NDDSUSERDllExport ChargeTypeIgniterTypeIgniterFunction
    : public ::ProjectDataManagement::PdmBase {
        int32_t chargeTypeId {};
        int32_t igniterTypeId {};
        int32_t igniterFunctionId {};
        ::ProjectDataManagement::IgniterFunctionBase igniterFunctionBaseId {};
        std::string impactArea {};
        int32_t impactRadius {};
        int32_t hazardDistance {};
        int32_t chargeLegacyId {};
        std::string properties {};

        ChargeTypeIgniterTypeIgniterFunction();

        ChargeTypeIgniterTypeIgniterFunction(int32_t id_,int32_t chargeTypeId_,int32_t igniterTypeId_,int32_t igniterFunctionId_,const ::ProjectDataManagement::IgniterFunctionBase& igniterFunctionBaseId_,const ::omg::types::string_view& impactArea_,int32_t impactRadius_,int32_t hazardDistance_,int32_t chargeLegacyId_,const ::omg::types::string_view& properties_);

    };

    NDDSUSERDllExport bool operator == (const ChargeTypeIgniterTypeIgniterFunction& a, const ChargeTypeIgniterTypeIgniterFunction& b);
    NDDSUSERDllExport bool operator != (const ChargeTypeIgniterTypeIgniterFunction& a, const ChargeTypeIgniterTypeIgniterFunction& b);
    NDDSUSERDllExport void swap(ChargeTypeIgniterTypeIgniterFunction& a, ChargeTypeIgniterTypeIgniterFunction& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const ChargeTypeIgniterTypeIgniterFunction& sample);

    #if (defined(RTI_WIN32) || defined (RTI_WINCE)) && defined(NDDS_USER_DLL_EXPORT)
    // On Windows, dll-export template instantiations of standard types used by
    // other dll-exported types
    template class NDDSUSERDllExport std::allocator< int32_t >;
    template class NDDSUSERDllExport std::vector< int32_t >;
    #endif
    struct NDDSUSERDllExport ChargeTypeLoadType
    : public ::ProjectDataManagement::PdmBase {
        int32_t chargeTypeId {};
        int32_t loadTypeId {};
        ::omg::types::sequence< int32_t > numbers {};
        std::string properties {};

        ChargeTypeLoadType();

        ChargeTypeLoadType(int32_t id_,int32_t chargeTypeId_,int32_t loadTypeId_,const ::omg::types::sequence< int32_t >& numbers_,const ::omg::types::string_view& properties_);

    };

    NDDSUSERDllExport bool operator == (const ChargeTypeLoadType& a, const ChargeTypeLoadType& b);
    NDDSUSERDllExport bool operator != (const ChargeTypeLoadType& a, const ChargeTypeLoadType& b);
    NDDSUSERDllExport void swap(ChargeTypeLoadType& a, ChargeTypeLoadType& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const ChargeTypeLoadType& sample);

    struct NDDSUSERDllExport EquipmentSystemEventFilter
    : public ::ProjectDataManagement::PdmBase {
        int32_t equipmentFunctionId {};
        int32_t subDeviceId {};
        int32_t deviceSpecificCode {};
        ::ProjectDataManagement::HgrMineSearchFilterType hgrMineSearchFilterType {};

        EquipmentSystemEventFilter();

        EquipmentSystemEventFilter(int32_t id_,int32_t equipmentFunctionId_,int32_t subDeviceId_,int32_t deviceSpecificCode_,const ::ProjectDataManagement::HgrMineSearchFilterType& hgrMineSearchFilterType_);

    };

    NDDSUSERDllExport bool operator == (const EquipmentSystemEventFilter& a, const EquipmentSystemEventFilter& b);
    NDDSUSERDllExport bool operator != (const EquipmentSystemEventFilter& a, const EquipmentSystemEventFilter& b);
    NDDSUSERDllExport void swap(EquipmentSystemEventFilter& a, EquipmentSystemEventFilter& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const EquipmentSystemEventFilter& sample);

    struct NDDSUSERDllExport EventFilterHgrMineSearch
    : public ::ProjectDataManagement::PdmBase {
        int32_t chargeTypeId {};
        ::ProjectDataManagement::HgrMineSearchFilterType hgrMineSearchFilterType {};

        EventFilterHgrMineSearch();

        EventFilterHgrMineSearch(int32_t id_,int32_t chargeTypeId_,const ::ProjectDataManagement::HgrMineSearchFilterType& hgrMineSearchFilterType_);

    };

    NDDSUSERDllExport bool operator == (const EventFilterHgrMineSearch& a, const EventFilterHgrMineSearch& b);
    NDDSUSERDllExport bool operator != (const EventFilterHgrMineSearch& a, const EventFilterHgrMineSearch& b);
    NDDSUSERDllExport void swap(EventFilterHgrMineSearch& a, EventFilterHgrMineSearch& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const EventFilterHgrMineSearch& sample);

    struct NDDSUSERDllExport FirePurpose
    : public ::ProjectDataManagement::PdmBaseName {
        std::string description {};
        std::string properties {};

        FirePurpose();

        FirePurpose(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& description_,const ::omg::types::string_view& properties_);

    };

    NDDSUSERDllExport bool operator == (const FirePurpose& a, const FirePurpose& b);
    NDDSUSERDllExport bool operator != (const FirePurpose& a, const FirePurpose& b);
    NDDSUSERDllExport void swap(FirePurpose& a, FirePurpose& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const FirePurpose& sample);

    struct NDDSUSERDllExport GearType
    : public ::ProjectDataManagement::PdmBaseName {
        ::ProjectDataManagement::GearClass gearClassId {};
        int32_t tasCode {};
        std::string properties {};

        GearType();

        GearType(int32_t id_,const ::omg::types::string_view& name_,const ::ProjectDataManagement::GearClass& gearClassId_,int32_t tasCode_,const ::omg::types::string_view& properties_);

    };

    NDDSUSERDllExport bool operator == (const GearType& a, const GearType& b);
    NDDSUSERDllExport bool operator != (const GearType& a, const GearType& b);
    NDDSUSERDllExport void swap(GearType& a, GearType& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const GearType& sample);

    struct NDDSUSERDllExport GearTypeChargeType
    : public ::ProjectDataManagement::PdmBase {
        int32_t chargeTypeId {};
        int32_t maxRange {};
        int32_t gearTypeId {};
        std::string properties {};

        GearTypeChargeType();

        GearTypeChargeType(int32_t id_,int32_t chargeTypeId_,int32_t maxRange_,int32_t gearTypeId_,const ::omg::types::string_view& properties_);

    };

    NDDSUSERDllExport bool operator == (const GearTypeChargeType& a, const GearTypeChargeType& b);
    NDDSUSERDllExport bool operator != (const GearTypeChargeType& a, const GearTypeChargeType& b);
    NDDSUSERDllExport void swap(GearTypeChargeType& a, GearTypeChargeType& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const GearTypeChargeType& sample);

    struct NDDSUSERDllExport IgniterFunction
    : public ::ProjectDataManagement::PdmBaseName {
        std::string shortName {};
        std::string properties {};

        IgniterFunction();

        IgniterFunction(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& shortName_,const ::omg::types::string_view& properties_);

    };

    NDDSUSERDllExport bool operator == (const IgniterFunction& a, const IgniterFunction& b);
    NDDSUSERDllExport bool operator != (const IgniterFunction& a, const IgniterFunction& b);
    NDDSUSERDllExport void swap(IgniterFunction& a, IgniterFunction& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const IgniterFunction& sample);

    struct NDDSUSERDllExport IgniterType
    : public ::ProjectDataManagement::PdmBaseName {
        std::string shortName {};
        std::string properties {};

        IgniterType();

        IgniterType(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& shortName_,const ::omg::types::string_view& properties_);

    };

    NDDSUSERDllExport bool operator == (const IgniterType& a, const IgniterType& b);
    NDDSUSERDllExport bool operator != (const IgniterType& a, const IgniterType& b);
    NDDSUSERDllExport void swap(IgniterType& a, IgniterType& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const IgniterType& sample);

    struct NDDSUSERDllExport InsertUpdateTranslationRequest {
        std::string isoCode {};
        std::string ctx {};
        std::string key {};
        std::string disambiguation {};
        std::string translation {};

        InsertUpdateTranslationRequest();

        InsertUpdateTranslationRequest(const ::omg::types::string_view& isoCode_,const ::omg::types::string_view& ctx_,const ::omg::types::string_view& key_,const ::omg::types::string_view& disambiguation_,const ::omg::types::string_view& translation_);

    };

    NDDSUSERDllExport bool operator == (const InsertUpdateTranslationRequest& a, const InsertUpdateTranslationRequest& b);
    NDDSUSERDllExport bool operator != (const InsertUpdateTranslationRequest& a, const InsertUpdateTranslationRequest& b);
    NDDSUSERDllExport void swap(InsertUpdateTranslationRequest& a, InsertUpdateTranslationRequest& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const InsertUpdateTranslationRequest& sample);

    struct NDDSUSERDllExport LanguageHmi
    : public ::ProjectDataManagement::PdmBaseName {
        std::string isoCode {};
        std::string dbLocale {};

        LanguageHmi();

        LanguageHmi(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& isoCode_,const ::omg::types::string_view& dbLocale_);

    };

    NDDSUSERDllExport bool operator == (const LanguageHmi& a, const LanguageHmi& b);
    NDDSUSERDllExport bool operator != (const LanguageHmi& a, const LanguageHmi& b);
    NDDSUSERDllExport void swap(LanguageHmi& a, LanguageHmi& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const LanguageHmi& sample);

    struct NDDSUSERDllExport LanguageXdu
    : public ::ProjectDataManagement::PdmBaseName {
        std::string isoCode {};

        LanguageXdu();

        explicit LanguageXdu(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& isoCode_);

    };

    NDDSUSERDllExport bool operator == (const LanguageXdu& a, const LanguageXdu& b);
    NDDSUSERDllExport bool operator != (const LanguageXdu& a, const LanguageXdu& b);
    NDDSUSERDllExport void swap(LanguageXdu& a, LanguageXdu& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const LanguageXdu& sample);

    struct NDDSUSERDllExport LoadType
    : public ::ProjectDataManagement::PdmBaseName {
        std::string shortName {};
        std::string properties {};

        LoadType();

        LoadType(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& shortName_,const ::omg::types::string_view& properties_);

    };

    NDDSUSERDllExport bool operator == (const LoadType& a, const LoadType& b);
    NDDSUSERDllExport bool operator != (const LoadType& a, const LoadType& b);
    NDDSUSERDllExport void swap(LoadType& a, LoadType& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const LoadType& sample);

    struct NDDSUSERDllExport NuclearPreset
    : public ::ProjectDataManagement::PdmBaseName {
        double detonationValue {};
        double impactRadius {};
        double borderLengthInner {};
        double borderLengthOuter {};

        NuclearPreset();

        NuclearPreset(int32_t id_,const ::omg::types::string_view& name_,double detonationValue_,double impactRadius_,double borderLengthInner_,double borderLengthOuter_);

    };

    NDDSUSERDllExport bool operator == (const NuclearPreset& a, const NuclearPreset& b);
    NDDSUSERDllExport bool operator != (const NuclearPreset& a, const NuclearPreset& b);
    NDDSUSERDllExport void swap(NuclearPreset& a, NuclearPreset& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const NuclearPreset& sample);

    struct NDDSUSERDllExport RadioGroup
    : public ::ProjectDataManagement::PdmBaseName {
        bool base_group {};
        int32_t issi {};
        int32_t group_issi1 {};
        int32_t group_issi2 {};
        std::string radioHostname {};
        int32_t radioPort {};
        std::string radioBackupHostname {};
        int32_t radioBackupPort {};

        RadioGroup();

        RadioGroup(int32_t id_,const ::omg::types::string_view& name_,bool base_group_,int32_t issi_,int32_t group_issi1_,int32_t group_issi2_,const ::omg::types::string_view& radioHostname_,int32_t radioPort_,const ::omg::types::string_view& radioBackupHostname_,int32_t radioBackupPort_);

    };

    NDDSUSERDllExport bool operator == (const RadioGroup& a, const RadioGroup& b);
    NDDSUSERDllExport bool operator != (const RadioGroup& a, const RadioGroup& b);
    NDDSUSERDllExport void swap(RadioGroup& a, RadioGroup& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const RadioGroup& sample);

    struct NDDSUSERDllExport SanitationInjury
    : public ::ProjectDataManagement::PdmBaseName {
        int32_t kind {};
        int32_t place1 {};
        int32_t place2 {};
        int32_t vbg {};

        SanitationInjury();

        SanitationInjury(int32_t id_,const ::omg::types::string_view& name_,int32_t kind_,int32_t place1_,int32_t place2_,int32_t vbg_);

    };

    NDDSUSERDllExport bool operator == (const SanitationInjury& a, const SanitationInjury& b);
    NDDSUSERDllExport bool operator != (const SanitationInjury& a, const SanitationInjury& b);
    NDDSUSERDllExport void swap(SanitationInjury& a, SanitationInjury& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const SanitationInjury& sample);

    struct NDDSUSERDllExport SanitationInjuryKind
    : public ::ProjectDataManagement::PdmBaseName {
        std::string version {};

        SanitationInjuryKind();

        explicit SanitationInjuryKind(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& version_);

    };

    NDDSUSERDllExport bool operator == (const SanitationInjuryKind& a, const SanitationInjuryKind& b);
    NDDSUSERDllExport bool operator != (const SanitationInjuryKind& a, const SanitationInjuryKind& b);
    NDDSUSERDllExport void swap(SanitationInjuryKind& a, SanitationInjuryKind& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const SanitationInjuryKind& sample);

    struct NDDSUSERDllExport SanitationInjuryPlace1
    : public ::ProjectDataManagement::PdmBaseName {
        std::string version {};

        SanitationInjuryPlace1();

        explicit SanitationInjuryPlace1(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& version_);

    };

    NDDSUSERDllExport bool operator == (const SanitationInjuryPlace1& a, const SanitationInjuryPlace1& b);
    NDDSUSERDllExport bool operator != (const SanitationInjuryPlace1& a, const SanitationInjuryPlace1& b);
    NDDSUSERDllExport void swap(SanitationInjuryPlace1& a, SanitationInjuryPlace1& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const SanitationInjuryPlace1& sample);

    struct NDDSUSERDllExport SanitationInjuryPlace2
    : public ::ProjectDataManagement::PdmBaseName {
        std::string version {};

        SanitationInjuryPlace2();

        explicit SanitationInjuryPlace2(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& version_);

    };

    NDDSUSERDllExport bool operator == (const SanitationInjuryPlace2& a, const SanitationInjuryPlace2& b);
    NDDSUSERDllExport bool operator != (const SanitationInjuryPlace2& a, const SanitationInjuryPlace2& b);
    NDDSUSERDllExport void swap(SanitationInjuryPlace2& a, SanitationInjuryPlace2& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const SanitationInjuryPlace2& sample);

    struct NDDSUSERDllExport SanitationMaterial
    : public ::ProjectDataManagement::PdmBaseName {
        std::string description {};
        std::string version {};

        SanitationMaterial();

        SanitationMaterial(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& description_,const ::omg::types::string_view& version_);

    };

    NDDSUSERDllExport bool operator == (const SanitationMaterial& a, const SanitationMaterial& b);
    NDDSUSERDllExport bool operator != (const SanitationMaterial& a, const SanitationMaterial& b);
    NDDSUSERDllExport void swap(SanitationMaterial& a, SanitationMaterial& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const SanitationMaterial& sample);

    struct NDDSUSERDllExport SanitationProcedure
    : public ::ProjectDataManagement::PdmBaseName {
        std::string type {};
        int32_t pdm_typeId {};
        int32_t minimumQualification {};
        std::string longName {};
        int64_t dataCode {};
        std::string version {};

        SanitationProcedure();

        SanitationProcedure(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& type_,int32_t pdm_typeId_,int32_t minimumQualification_,const ::omg::types::string_view& longName_,int64_t dataCode_,const ::omg::types::string_view& version_);

    };

    NDDSUSERDllExport bool operator == (const SanitationProcedure& a, const SanitationProcedure& b);
    NDDSUSERDllExport bool operator != (const SanitationProcedure& a, const SanitationProcedure& b);
    NDDSUSERDllExport void swap(SanitationProcedure& a, SanitationProcedure& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const SanitationProcedure& sample);

    struct NDDSUSERDllExport TargetSubType
    : public ::ProjectDataManagement::PdmBaseName {
        std::string abbreviation {};
        std::string properties {};

        TargetSubType();

        TargetSubType(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& abbreviation_,const ::omg::types::string_view& properties_);

    };

    NDDSUSERDllExport bool operator == (const TargetSubType& a, const TargetSubType& b);
    NDDSUSERDllExport bool operator != (const TargetSubType& a, const TargetSubType& b);
    NDDSUSERDllExport void swap(TargetSubType& a, TargetSubType& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const TargetSubType& sample);

    struct NDDSUSERDllExport TargetType
    : public ::ProjectDataManagement::PdmBaseName {
        std::string abbreviation {};
        std::string properties {};

        TargetType();

        TargetType(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& abbreviation_,const ::omg::types::string_view& properties_);

    };

    NDDSUSERDllExport bool operator == (const TargetType& a, const TargetType& b);
    NDDSUSERDllExport bool operator != (const TargetType& a, const TargetType& b);
    NDDSUSERDllExport void swap(TargetType& a, TargetType& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const TargetType& sample);

    struct NDDSUSERDllExport TargetTypeTargetSubType
    : public ::ProjectDataManagement::PdmBase {
        int32_t targetTypeId {};
        int32_t targetSubTypeId {};
        std::string properties {};

        TargetTypeTargetSubType();

        TargetTypeTargetSubType(int32_t id_,int32_t targetTypeId_,int32_t targetSubTypeId_,const ::omg::types::string_view& properties_);

    };

    NDDSUSERDllExport bool operator == (const TargetTypeTargetSubType& a, const TargetTypeTargetSubType& b);
    NDDSUSERDllExport bool operator != (const TargetTypeTargetSubType& a, const TargetTypeTargetSubType& b);
    NDDSUSERDllExport void swap(TargetTypeTargetSubType& a, TargetTypeTargetSubType& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const TargetTypeTargetSubType& sample);

    #if (defined(RTI_WIN32) || defined (RTI_WINCE)) && defined(NDDS_USER_DLL_EXPORT)
    // On Windows, dll-export template instantiations of standard types used by
    // other dll-exported types
    template class NDDSUSERDllExport std::allocator< uint8_t >;
    template class NDDSUSERDllExport std::vector< uint8_t >;
    #endif
    struct NDDSUSERDllExport TranslationBlob
    : public ::ProjectDataManagement::PdmBase {
        ::omg::types::sequence< uint8_t > payload {};
        std::string md5sum {};

        TranslationBlob();

        TranslationBlob(int32_t id_,const ::omg::types::sequence< uint8_t >& payload_,const ::omg::types::string_view& md5sum_);

    };

    NDDSUSERDllExport bool operator == (const TranslationBlob& a, const TranslationBlob& b);
    NDDSUSERDllExport bool operator != (const TranslationBlob& a, const TranslationBlob& b);
    NDDSUSERDllExport void swap(TranslationBlob& a, TranslationBlob& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const TranslationBlob& sample);

    struct NDDSUSERDllExport UpdateChargeNamesRequest
    : public ::ProjectDataManagement::PdmBaseName {
        std::string shortName {};

        UpdateChargeNamesRequest();

        explicit UpdateChargeNamesRequest(int32_t id_,const ::omg::types::string_view& name_,const ::omg::types::string_view& shortName_);

    };

    NDDSUSERDllExport bool operator == (const UpdateChargeNamesRequest& a, const UpdateChargeNamesRequest& b);
    NDDSUSERDllExport bool operator != (const UpdateChargeNamesRequest& a, const UpdateChargeNamesRequest& b);
    NDDSUSERDllExport void swap(UpdateChargeNamesRequest& a, UpdateChargeNamesRequest& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const UpdateChargeNamesRequest& sample);

    struct NDDSUSERDllExport VulnerabilityKind
    : public ::ProjectDataManagement::PdmBaseName {
        int32_t playerTypeClassId {};
        int32_t taVulnerabilityKind {};
        ::ProjectDataManagement::VulnerabilityClass vulnerabilityClassId {};

        VulnerabilityKind();

        VulnerabilityKind(int32_t id_,const ::omg::types::string_view& name_,int32_t playerTypeClassId_,int32_t taVulnerabilityKind_,const ::ProjectDataManagement::VulnerabilityClass& vulnerabilityClassId_);

    };

    NDDSUSERDllExport bool operator == (const VulnerabilityKind& a, const VulnerabilityKind& b);
    NDDSUSERDllExport bool operator != (const VulnerabilityKind& a, const VulnerabilityKind& b);
    NDDSUSERDllExport void swap(VulnerabilityKind& a, VulnerabilityKind& b)  noexcept;

    NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const VulnerabilityKind& sample);

} // namespace ProjectDataManagement  

#ifdef NDDS_STANDALONE_TYPE
namespace rti { 
    namespace topic {
    }
}
#else

namespace rti {
    namespace flat {
        namespace topic {
        }
    }
}
namespace dds {
    namespace topic {

        template<>
        struct topic_type_name< ::ProjectDataManagement::PdmBase > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::PdmBase";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::PdmBase > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::PdmBase > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::PdmBase& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::PdmBase& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::PdmBase& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::PdmBase& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::PdmBaseName > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::PdmBaseName";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::PdmBaseName > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::PdmBaseName > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::PdmBaseName& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::PdmBaseName& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::PdmBaseName& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::PdmBaseName& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::BiteComponentText > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::BiteComponentText";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::BiteComponentText > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::BiteComponentText > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::BiteComponentText& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::BiteComponentText& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::BiteComponentText& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::BiteComponentText& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::BuildingChargeEffect > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::BuildingChargeEffect";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::BuildingChargeEffect > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::BuildingChargeEffect > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::BuildingChargeEffect& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::BuildingChargeEffect& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::BuildingChargeEffect& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::BuildingChargeEffect& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::CanComponentString > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::CanComponentString";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::CanComponentString > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::CanComponentString > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::CanComponentString& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::CanComponentString& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::CanComponentString& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::CanComponentString& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::CasEffect > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::CasEffect";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::CasEffect > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::CasEffect > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::CasEffect& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::CasEffect& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::CasEffect& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::CasEffect& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::ChargeType > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::ChargeType";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::ChargeType > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::ChargeType > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::ChargeType& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::ChargeType& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::ChargeType& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::ChargeType& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::ChargeTypeLoadType > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::ChargeTypeLoadType";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::ChargeTypeLoadType > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::ChargeTypeLoadType > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::ChargeTypeLoadType& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::ChargeTypeLoadType& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::ChargeTypeLoadType& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::ChargeTypeLoadType& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::EquipmentSystemEventFilter > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::EquipmentSystemEventFilter";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::EquipmentSystemEventFilter > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::EquipmentSystemEventFilter > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::EquipmentSystemEventFilter& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::EquipmentSystemEventFilter& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::EquipmentSystemEventFilter& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::EquipmentSystemEventFilter& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::EventFilterHgrMineSearch > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::EventFilterHgrMineSearch";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::EventFilterHgrMineSearch > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::EventFilterHgrMineSearch > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::EventFilterHgrMineSearch& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::EventFilterHgrMineSearch& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::EventFilterHgrMineSearch& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::EventFilterHgrMineSearch& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::FirePurpose > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::FirePurpose";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::FirePurpose > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::FirePurpose > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::FirePurpose& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::FirePurpose& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::FirePurpose& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::FirePurpose& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::GearType > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::GearType";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::GearType > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::GearType > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::GearType& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::GearType& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::GearType& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::GearType& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::GearTypeChargeType > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::GearTypeChargeType";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::GearTypeChargeType > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::GearTypeChargeType > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::GearTypeChargeType& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::GearTypeChargeType& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::GearTypeChargeType& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::GearTypeChargeType& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::IgniterFunction > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::IgniterFunction";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::IgniterFunction > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::IgniterFunction > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::IgniterFunction& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::IgniterFunction& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::IgniterFunction& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::IgniterFunction& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::IgniterType > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::IgniterType";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::IgniterType > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::IgniterType > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::IgniterType& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::IgniterType& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::IgniterType& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::IgniterType& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::InsertUpdateTranslationRequest > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::InsertUpdateTranslationRequest";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::InsertUpdateTranslationRequest > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::InsertUpdateTranslationRequest > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::InsertUpdateTranslationRequest& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::InsertUpdateTranslationRequest& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::InsertUpdateTranslationRequest& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::InsertUpdateTranslationRequest& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::LanguageHmi > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::LanguageHmi";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::LanguageHmi > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::LanguageHmi > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::LanguageHmi& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::LanguageHmi& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::LanguageHmi& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::LanguageHmi& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::LanguageXdu > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::LanguageXdu";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::LanguageXdu > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::LanguageXdu > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::LanguageXdu& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::LanguageXdu& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::LanguageXdu& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::LanguageXdu& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::LoadType > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::LoadType";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::LoadType > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::LoadType > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::LoadType& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::LoadType& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::LoadType& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::LoadType& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::NuclearPreset > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::NuclearPreset";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::NuclearPreset > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::NuclearPreset > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::NuclearPreset& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::NuclearPreset& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::NuclearPreset& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::NuclearPreset& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::RadioGroup > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::RadioGroup";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::RadioGroup > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::RadioGroup > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::RadioGroup& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::RadioGroup& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::RadioGroup& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::RadioGroup& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::SanitationInjury > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::SanitationInjury";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::SanitationInjury > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::SanitationInjury > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::SanitationInjury& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::SanitationInjury& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::SanitationInjury& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::SanitationInjury& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::SanitationInjuryKind > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::SanitationInjuryKind";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::SanitationInjuryKind > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::SanitationInjuryKind > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::SanitationInjuryKind& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::SanitationInjuryKind& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::SanitationInjuryKind& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::SanitationInjuryKind& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::SanitationInjuryPlace1 > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::SanitationInjuryPlace1";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::SanitationInjuryPlace1 > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::SanitationInjuryPlace1 > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::SanitationInjuryPlace1& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::SanitationInjuryPlace1& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::SanitationInjuryPlace1& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::SanitationInjuryPlace1& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::SanitationInjuryPlace2 > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::SanitationInjuryPlace2";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::SanitationInjuryPlace2 > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::SanitationInjuryPlace2 > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::SanitationInjuryPlace2& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::SanitationInjuryPlace2& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::SanitationInjuryPlace2& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::SanitationInjuryPlace2& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::SanitationMaterial > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::SanitationMaterial";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::SanitationMaterial > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::SanitationMaterial > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::SanitationMaterial& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::SanitationMaterial& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::SanitationMaterial& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::SanitationMaterial& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::SanitationProcedure > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::SanitationProcedure";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::SanitationProcedure > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::SanitationProcedure > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::SanitationProcedure& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::SanitationProcedure& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::SanitationProcedure& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::SanitationProcedure& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::TargetSubType > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::TargetSubType";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::TargetSubType > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::TargetSubType > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::TargetSubType& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::TargetSubType& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::TargetSubType& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::TargetSubType& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::TargetType > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::TargetType";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::TargetType > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::TargetType > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::TargetType& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::TargetType& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::TargetType& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::TargetType& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::TargetTypeTargetSubType > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::TargetTypeTargetSubType";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::TargetTypeTargetSubType > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::TargetTypeTargetSubType > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::TargetTypeTargetSubType& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::TargetTypeTargetSubType& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::TargetTypeTargetSubType& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::TargetTypeTargetSubType& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::TranslationBlob > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::TranslationBlob";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::TranslationBlob > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::TranslationBlob > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::TranslationBlob& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::TranslationBlob& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::TranslationBlob& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::TranslationBlob& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::UpdateChargeNamesRequest > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::UpdateChargeNamesRequest";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::UpdateChargeNamesRequest > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::UpdateChargeNamesRequest > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::UpdateChargeNamesRequest& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::UpdateChargeNamesRequest& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::UpdateChargeNamesRequest& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::UpdateChargeNamesRequest& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::ProjectDataManagement::VulnerabilityKind > {
            NDDSUSERDllExport static std::string value() {
                return "ProjectDataManagement::VulnerabilityKind";
            }
        };

        template<>
        struct is_topic_type< ::ProjectDataManagement::VulnerabilityKind > : public ::dds::core::true_type {};

        template<>
        struct topic_type_support< ::ProjectDataManagement::VulnerabilityKind > {
            NDDSUSERDllExport 
            static void register_type(
                ::dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport 
            static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, 
                const ::ProjectDataManagement::VulnerabilityKind& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());

            NDDSUSERDllExport 
            static void from_cdr_buffer(::ProjectDataManagement::VulnerabilityKind& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::ProjectDataManagement::VulnerabilityKind& sample);

            NDDSUSERDllExport 
            static void allocate_sample(::ProjectDataManagement::VulnerabilityKind& sample, int, int);

            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
    }
}

namespace rti { 
    namespace topic {

        template<>
        struct dynamic_type< ::ProjectDataManagement::PdmBase > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::PdmBase > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::PdmBaseName > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::PdmBaseName > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::BiteComponentText > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::BiteComponentText > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::BuildingChargeEffect > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::BuildingChargeEffect > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::CanComponentString > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::CanComponentString > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::CasEffect > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::CasEffect > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::ChargeType > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::ChargeType > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::ChargeTypeLoadType > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::ChargeTypeLoadType > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::EquipmentSystemEventFilter > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::EquipmentSystemEventFilter > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::EventFilterHgrMineSearch > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::EventFilterHgrMineSearch > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::FirePurpose > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::FirePurpose > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::GearType > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::GearType > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::GearTypeChargeType > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::GearTypeChargeType > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::IgniterFunction > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::IgniterFunction > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::IgniterType > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::IgniterType > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::InsertUpdateTranslationRequest > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::InsertUpdateTranslationRequest > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::LanguageHmi > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::LanguageHmi > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::LanguageXdu > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::LanguageXdu > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::LoadType > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::LoadType > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::NuclearPreset > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::NuclearPreset > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::RadioGroup > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::RadioGroup > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::SanitationInjury > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::SanitationInjury > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::SanitationInjuryKind > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::SanitationInjuryKind > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::SanitationInjuryPlace1 > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::SanitationInjuryPlace1 > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::SanitationInjuryPlace2 > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::SanitationInjuryPlace2 > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::SanitationMaterial > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::SanitationMaterial > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::SanitationProcedure > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::SanitationProcedure > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::TargetSubType > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::TargetSubType > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::TargetType > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::TargetType > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::TargetTypeTargetSubType > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::TargetTypeTargetSubType > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::TranslationBlob > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::TranslationBlob > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::UpdateChargeNamesRequest > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::UpdateChargeNamesRequest > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

        template<>
        struct dynamic_type< ::ProjectDataManagement::VulnerabilityKind > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };

        template <>
        struct extensibility< ::ProjectDataManagement::VulnerabilityKind > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };

    }
}

#endif // NDDS_STANDALONE_TYPE
#if defined(NDDS_USER_DLL_EXPORT) || defined(NDDS_USER_SYMBOL_EXPORT)
#undef NDDSUSERDllExport
#define NDDSUSERDllExport
#endif

#endif // pdm_713756303_hpp