#include "wire_Common.hpp"
#include "../obapi_runtime.hpp"
#include <type_traits>
static_assert(std::is_same<::M_Common::ObjectIdType, std::string>::value, "typedef M_Common::ObjectIdType differs from the data model");
static_assert(std::is_same<::M_Common::ObjectIdOptionalType, std::vector<std::string>>::value, "typedef M_Common::ObjectIdOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::ObjectIdListType, std::vector<std::string>>::value, "typedef M_Common::ObjectIdListType differs from the data model");
static_assert(std::is_same<::M_Common::DoubleOptionalType, std::vector<double>>::value, "typedef M_Common::DoubleOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::DoubleListType, std::vector<double>>::value, "typedef M_Common::DoubleListType differs from the data model");
static_assert(std::is_same<::M_Common::DoubleMatrixType, std::vector<std::vector<double>>>::value, "typedef M_Common::DoubleMatrixType differs from the data model");
static_assert(std::is_same<::M_Common::LongOptionalType, std::vector<int32_t>>::value, "typedef M_Common::LongOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::ULongOptionalType, std::vector<uint32_t>>::value, "typedef M_Common::ULongOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::ULongListType, std::vector<uint32_t>>::value, "typedef M_Common::ULongListType differs from the data model");
static_assert(std::is_same<::M_Common::ULongLongListType, std::vector<uint64_t>>::value, "typedef M_Common::ULongLongListType differs from the data model");
static_assert(std::is_same<::M_Common::LongLongOptionalType, std::vector<int64_t>>::value, "typedef M_Common::LongLongOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::ULongLongOptionalType, std::vector<uint64_t>>::value, "typedef M_Common::ULongLongOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::UShortOptionalType, std::vector<uint16_t>>::value, "typedef M_Common::UShortOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::BooleanOptionalType, std::vector<bool>>::value, "typedef M_Common::BooleanOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::ByteSeqType, std::vector<uint8_t>>::value, "typedef M_Common::ByteSeqType differs from the data model");
static_assert(std::is_same<::M_Common::ByteOptionalType, std::vector<uint8_t>>::value, "typedef M_Common::ByteOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::StringOptionalType, std::vector<std::string>>::value, "typedef M_Common::StringOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::StringListType, std::vector<std::string>>::value, "typedef M_Common::StringListType differs from the data model");
static_assert(std::is_same<::M_Common::BoundedStringType, std::string>::value, "typedef M_Common::BoundedStringType differs from the data model");
static_assert(std::is_same<::M_Common::BoundedStringOptionalType, std::vector<std::string>>::value, "typedef M_Common::BoundedStringOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::ProportionalType, double>::value, "typedef M_Common::ProportionalType differs from the data model");
static_assert(std::is_same<::M_Common::ProportionalOptionalType, std::vector<double>>::value, "typedef M_Common::ProportionalOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::ProportionalListType, std::vector<double>>::value, "typedef M_Common::ProportionalListType differs from the data model");
static_assert(std::is_same<::M_Common::PercentType, double>::value, "typedef M_Common::PercentType differs from the data model");
static_assert(std::is_same<::M_Common::PercentOptionalType, std::vector<double>>::value, "typedef M_Common::PercentOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::PercentListType, std::vector<double>>::value, "typedef M_Common::PercentListType differs from the data model");
static_assert(std::is_same<::M_Common::TimeSecondsType, double>::value, "typedef M_Common::TimeSecondsType differs from the data model");
static_assert(std::is_same<::M_Common::TimeSecondsOptionalType, std::vector<double>>::value, "typedef M_Common::TimeSecondsOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::TimeSecondsListType, std::vector<double>>::value, "typedef M_Common::TimeSecondsListType differs from the data model");
static_assert(std::is_same<::M_Common::MassKilogramsType, double>::value, "typedef M_Common::MassKilogramsType differs from the data model");
static_assert(std::is_same<::M_Common::MassKilogramsOptionalType, std::vector<double>>::value, "typedef M_Common::MassKilogramsOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::MomentOfInertiaKilogramMetresSquaredType, double>::value, "typedef M_Common::MomentOfInertiaKilogramMetresSquaredType differs from the data model");
static_assert(std::is_same<::M_Common::TemperatureKelvinsType, double>::value, "typedef M_Common::TemperatureKelvinsType differs from the data model");
static_assert(std::is_same<::M_Common::TemperatureKelvinsOptionalType, std::vector<double>>::value, "typedef M_Common::TemperatureKelvinsOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::TemperatureKelvinsListType, std::vector<double>>::value, "typedef M_Common::TemperatureKelvinsListType differs from the data model");
static_assert(std::is_same<::M_Common::PressurePascalsType, double>::value, "typedef M_Common::PressurePascalsType differs from the data model");
static_assert(std::is_same<::M_Common::PressurePascalsOptionalType, std::vector<double>>::value, "typedef M_Common::PressurePascalsOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::PowerWattsType, double>::value, "typedef M_Common::PowerWattsType differs from the data model");
static_assert(std::is_same<::M_Common::PowerWattsOptionalType, std::vector<double>>::value, "typedef M_Common::PowerWattsOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::FrequencyHertzType, double>::value, "typedef M_Common::FrequencyHertzType differs from the data model");
static_assert(std::is_same<::M_Common::FrequencyHertzOptionalType, std::vector<double>>::value, "typedef M_Common::FrequencyHertzOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::AmplitudeDecibelsType, double>::value, "typedef M_Common::AmplitudeDecibelsType differs from the data model");
static_assert(std::is_same<::M_Common::AmplitudeDecibelsOptionalType, std::vector<double>>::value, "typedef M_Common::AmplitudeDecibelsOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::AmplitudeScaledType, double>::value, "typedef M_Common::AmplitudeScaledType differs from the data model");
static_assert(std::is_same<::M_Common::AmplitudeScaledOptionalType, std::vector<double>>::value, "typedef M_Common::AmplitudeScaledOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::PowerLevelDecibelWattsType, double>::value, "typedef M_Common::PowerLevelDecibelWattsType differs from the data model");
static_assert(std::is_same<::M_Common::PowerLevelDecibelWattsOptionalType, std::vector<double>>::value, "typedef M_Common::PowerLevelDecibelWattsOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::MagneticFluxDensityTeslasType, double>::value, "typedef M_Common::MagneticFluxDensityTeslasType differs from the data model");
static_assert(std::is_same<::M_Common::MagneticFluxDensityTeslasOptionalType, std::vector<double>>::value, "typedef M_Common::MagneticFluxDensityTeslasOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::VoltageVoltsType, double>::value, "typedef M_Common::VoltageVoltsType differs from the data model");
static_assert(std::is_same<::M_Common::VoltageVoltsOptionalType, std::vector<double>>::value, "typedef M_Common::VoltageVoltsOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::VoltageVoltsListType, std::vector<double>>::value, "typedef M_Common::VoltageVoltsListType differs from the data model");
static_assert(std::is_same<::M_Common::CurrentAmperesType, double>::value, "typedef M_Common::CurrentAmperesType differs from the data model");
static_assert(std::is_same<::M_Common::CurrentAmperesOptionalType, std::vector<double>>::value, "typedef M_Common::CurrentAmperesOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::CurrentAmperesListType, std::vector<double>>::value, "typedef M_Common::CurrentAmperesListType differs from the data model");
static_assert(std::is_same<::M_Common::RateOfFireRpmType, double>::value, "typedef M_Common::RateOfFireRpmType differs from the data model");
static_assert(std::is_same<::M_Common::RateOfFireRpmOptionalType, std::vector<double>>::value, "typedef M_Common::RateOfFireRpmOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::DistanceMetersType, double>::value, "typedef M_Common::DistanceMetersType differs from the data model");
static_assert(std::is_same<::M_Common::DistanceMetersOptionalType, std::vector<double>>::value, "typedef M_Common::DistanceMetersOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::AngleRadiansType, double>::value, "typedef M_Common::AngleRadiansType differs from the data model");
static_assert(std::is_same<::M_Common::AngleRadiansOptionalType, std::vector<double>>::value, "typedef M_Common::AngleRadiansOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::AngleDegreesType, double>::value, "typedef M_Common::AngleDegreesType differs from the data model");
static_assert(std::is_same<::M_Common::AngleDegreesOptionalType, std::vector<double>>::value, "typedef M_Common::AngleDegreesOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::AngleDegreesListType, std::vector<double>>::value, "typedef M_Common::AngleDegreesListType differs from the data model");
static_assert(std::is_same<::M_Common::AngleRateDegreesPerSecType, double>::value, "typedef M_Common::AngleRateDegreesPerSecType differs from the data model");
static_assert(std::is_same<::M_Common::AngleRateDegreesPerSecOptionalType, std::vector<double>>::value, "typedef M_Common::AngleRateDegreesPerSecOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::AngularAccelerationDegreesPerSecPerSecType, double>::value, "typedef M_Common::AngularAccelerationDegreesPerSecPerSecType differs from the data model");
static_assert(std::is_same<::M_Common::AngularAccelerationDegreesPerSecPerSecOptionalType, std::vector<double>>::value, "typedef M_Common::AngularAccelerationDegreesPerSecPerSecOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::SpeedMetersPerSecType, double>::value, "typedef M_Common::SpeedMetersPerSecType differs from the data model");
static_assert(std::is_same<::M_Common::SpeedMetersPerSecOptionalType, std::vector<double>>::value, "typedef M_Common::SpeedMetersPerSecOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::AccelerationMetersPerSecPerSecType, double>::value, "typedef M_Common::AccelerationMetersPerSecPerSecType differs from the data model");
static_assert(std::is_same<::M_Common::AccelerationMetersPerSecPerSecOptionalType, std::vector<double>>::value, "typedef M_Common::AccelerationMetersPerSecPerSecOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::BitrateKiloBitsPerSecType, uint32_t>::value, "typedef M_Common::BitrateKiloBitsPerSecType differs from the data model");
static_assert(std::is_same<::M_Common::BitrateKiloBitsPerSecOptionalType, std::vector<uint32_t>>::value, "typedef M_Common::BitrateKiloBitsPerSecOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::DetectionType, uint32_t>::value, "typedef M_Common::DetectionType differs from the data model");
static_assert(std::is_same<::M_Common::SensorType, uint32_t>::value, "typedef M_Common::SensorType differs from the data model");
static_assert(std::is_same<::M_Common::SensorOptionalType, std::vector<uint32_t>>::value, "typedef M_Common::SensorOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::IdentityType, uint32_t>::value, "typedef M_Common::IdentityType differs from the data model");
static_assert(std::is_same<::M_Common::IdentityOptionalType, std::vector<uint32_t>>::value, "typedef M_Common::IdentityOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::ThreatLevelType, int32_t>::value, "typedef M_Common::ThreatLevelType differs from the data model");
static_assert(std::is_same<::M_Common::ThreatLevelOptionalType, std::vector<int32_t>>::value, "typedef M_Common::ThreatLevelOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ObjectClassificationType::Category), uint32_t>::value, "M_Common::ObjectClassificationType field Category differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ObjectClassificationType::AbstractionLayer), std::string>::value, "M_Common::ObjectClassificationType field AbstractionLayer differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ObjectClassificationType::Confidence), std::vector<double>>::value, "M_Common::ObjectClassificationType field Confidence differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ObjectClassificationType::Priority), std::vector<double>>::value, "M_Common::ObjectClassificationType field Priority differs from the data model");
static_assert(std::is_same<::M_Common::ObjectClassificationOptionalType, std::vector<::M_Common::ObjectClassificationType>>::value, "typedef M_Common::ObjectClassificationOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::ObjectClassificationListType, std::vector<::M_Common::ObjectClassificationType>>::value, "typedef M_Common::ObjectClassificationListType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::GeneralStatus::Not_Supported) == 0u, "enum value M_Common::GeneralStatus::Type::Not_Supported differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::GeneralStatus::Enabled) == 1u, "enum value M_Common::GeneralStatus::Type::Enabled differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::GeneralStatus::Disabled) == 2u, "enum value M_Common::GeneralStatus::Type::Disabled differs from the data model");
static_assert(std::is_same<::M_Common::GeneralStatusOptionalType, std::vector<::M_Common::GeneralStatus::Type>>::value, "typedef M_Common::GeneralStatusOptionalType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::PropertyAccessKind::Undefined) == 0u, "enum value M_Common::PropertyAccessKind::Type::Undefined differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::PropertyAccessKind::Read_Only) == 1u, "enum value M_Common::PropertyAccessKind::Type::Read_Only differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::PropertyAccessKind::Write_Only) == 2u, "enum value M_Common::PropertyAccessKind::Type::Write_Only differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::PropertyAccessKind::Read_Write) == 3u, "enum value M_Common::PropertyAccessKind::Type::Read_Write differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PropertyType::Name), std::string>::value, "M_Common::PropertyType field Name differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PropertyType::StrValue), std::string>::value, "M_Common::PropertyType field StrValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PropertyType::DoubleValue), std::vector<double>>::value, "M_Common::PropertyType field DoubleValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PropertyType::LongValue), std::vector<int32_t>>::value, "M_Common::PropertyType field LongValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PropertyType::AccessMode), ::M_Common::PropertyAccessKind::Type>::value, "M_Common::PropertyType field AccessMode differs from the data model");
static_assert(std::is_same<::M_Common::PropertyOptionalType, std::vector<::M_Common::PropertyType>>::value, "typedef M_Common::PropertyOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::PropertyListType, std::vector<::M_Common::PropertyType>>::value, "typedef M_Common::PropertyListType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationModeStateKind::Undefined) == 0u, "enum value M_Common::OperationModeStateKind::Type::Undefined differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationModeStateKind::Off) == 1u, "enum value M_Common::OperationModeStateKind::Type::Off differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationModeStateKind::On) == 2u, "enum value M_Common::OperationModeStateKind::Type::On differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationModeStateKind::Standby) == 3u, "enum value M_Common::OperationModeStateKind::Type::Standby differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationModeStateKind::Init) == 4u, "enum value M_Common::OperationModeStateKind::Type::Init differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationModeStateKind::Shutdown) == 5u, "enum value M_Common::OperationModeStateKind::Type::Shutdown differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationModeStateKind::Normal) == 6u, "enum value M_Common::OperationModeStateKind::Type::Normal differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationModeStateKind::Manual) == 7u, "enum value M_Common::OperationModeStateKind::Type::Manual differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationModeStateKind::Auto) == 8u, "enum value M_Common::OperationModeStateKind::Type::Auto differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationModeStateKind::Calibrating) == 9u, "enum value M_Common::OperationModeStateKind::Type::Calibrating differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationModeStateKind::Maintenance) == 10u, "enum value M_Common::OperationModeStateKind::Type::Maintenance differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationModeStateKind::Simulation) == 11u, "enum value M_Common::OperationModeStateKind::Type::Simulation differs from the data model");
static_assert(std::is_same<::M_Common::OperationModeStateOptionalType, std::vector<::M_Common::OperationModeStateKind::Type>>::value, "typedef M_Common::OperationModeStateOptionalType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ModeTransitionKind::Undefined) == 0u, "enum value M_Common::ModeTransitionKind::Type::Undefined differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ModeTransitionKind::In_Progress) == 1u, "enum value M_Common::ModeTransitionKind::Type::In_Progress differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ModeTransitionKind::Complete) == 2u, "enum value M_Common::ModeTransitionKind::Type::Complete differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ModeTransitionKind::Error) == 3u, "enum value M_Common::ModeTransitionKind::Type::Error differs from the data model");
static_assert(std::is_same<::M_Common::ModeTransitionOptionalType, std::vector<::M_Common::ModeTransitionKind::Type>>::value, "typedef M_Common::ModeTransitionOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationModeType::Name), std::string>::value, "M_Common::OperationModeType field Name differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationModeType::EnumeratedValue), std::vector<::M_Common::OperationModeStateKind::Type>>::value, "M_Common::OperationModeType field EnumeratedValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationModeType::IntegerValue), std::vector<int32_t>>::value, "M_Common::OperationModeType field IntegerValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationModeType::TextualValue), std::vector<std::string>>::value, "M_Common::OperationModeType field TextualValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationModeType::TransitionState), std::vector<::M_Common::ModeTransitionKind::Type>>::value, "M_Common::OperationModeType field TransitionState differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationModeType::AdditionalInfo), std::vector<::M_Common::PropertyType>>::value, "M_Common::OperationModeType field AdditionalInfo differs from the data model");
static_assert(std::is_same<::M_Common::OperationModeOptionalType, std::vector<::M_Common::OperationModeType>>::value, "typedef M_Common::OperationModeOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::OperationModeListType, std::vector<::M_Common::OperationModeType>>::value, "typedef M_Common::OperationModeListType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationFaultStateKind::Undefined) == 0u, "enum value M_Common::OperationFaultStateKind::Type::Undefined differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationFaultStateKind::None) == 1u, "enum value M_Common::OperationFaultStateKind::Type::None differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationFaultStateKind::Init_Failure) == 2u, "enum value M_Common::OperationFaultStateKind::Type::Init_Failure differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationFaultStateKind::Warning) == 3u, "enum value M_Common::OperationFaultStateKind::Type::Warning differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationFaultStateKind::Failure) == 4u, "enum value M_Common::OperationFaultStateKind::Type::Failure differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationFaultStateKind::Critical) == 5u, "enum value M_Common::OperationFaultStateKind::Type::Critical differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OperationFaultStateKind::Fatal) == 6u, "enum value M_Common::OperationFaultStateKind::Type::Fatal differs from the data model");
static_assert(std::is_same<::M_Common::OperationFaultStateOptionalType, std::vector<::M_Common::OperationFaultStateKind::Type>>::value, "typedef M_Common::OperationFaultStateOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationFaultType::Name), std::string>::value, "M_Common::OperationFaultType field Name differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationFaultType::EnumeratedValue), std::vector<::M_Common::OperationFaultStateKind::Type>>::value, "M_Common::OperationFaultType field EnumeratedValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationFaultType::IntegerValue), std::vector<int32_t>>::value, "M_Common::OperationFaultType field IntegerValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationFaultType::TextualValue), std::vector<std::string>>::value, "M_Common::OperationFaultType field TextualValue differs from the data model");
static_assert(std::is_same<::M_Common::OperationFaultListType, std::vector<::M_Common::OperationFaultType>>::value, "typedef M_Common::OperationFaultListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ModeTransitionInfoType::LastState), std::vector<::M_Common::OperationModeType>>::value, "M_Common::ModeTransitionInfoType field LastState differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ModeTransitionInfoType::RequestedState), std::vector<::M_Common::OperationModeType>>::value, "M_Common::ModeTransitionInfoType field RequestedState differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ModeTransitionInfoType::Errors), std::vector<::M_Common::OperationFaultType>>::value, "M_Common::ModeTransitionInfoType field Errors differs from the data model");
static_assert(std::is_same<::M_Common::ModeTransitionInfoOptionalType, std::vector<::M_Common::ModeTransitionInfoType>>::value, "typedef M_Common::ModeTransitionInfoOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationStatusType::Mode), std::vector<::M_Common::OperationModeType>>::value, "M_Common::OperationStatusType field Mode differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationStatusType::ModeTransitionInfo), std::vector<::M_Common::ModeTransitionInfoType>>::value, "M_Common::OperationStatusType field ModeTransitionInfo differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationStatusType::PermittedModeTransitionList), std::vector<::M_Common::OperationModeType>>::value, "M_Common::OperationStatusType field PermittedModeTransitionList differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationStatusType::SubmodeList), std::vector<::M_Common::OperationModeType>>::value, "M_Common::OperationStatusType field SubmodeList differs from the data model");
static_assert(std::is_same<decltype(::M_Common::OperationStatusType::Faults), std::vector<::M_Common::OperationFaultType>>::value, "M_Common::OperationStatusType field Faults differs from the data model");
static_assert(std::is_same<::M_Common::OperationStatusOptionalType, std::vector<::M_Common::OperationStatusType>>::value, "typedef M_Common::OperationStatusOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::OperationStatusListType, std::vector<::M_Common::OperationStatusType>>::value, "typedef M_Common::OperationStatusListType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::StorageKind::Undefined) == 0u, "enum value M_Common::StorageKind::Type::Undefined differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::StorageKind::Not_Persistent) == 1u, "enum value M_Common::StorageKind::Type::Not_Persistent differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::StorageKind::Persistent) == 2u, "enum value M_Common::StorageKind::Type::Persistent differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OpticalSensorMode::Infrared) == 0u, "enum value M_Common::OpticalSensorMode::Type::Infrared differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::OpticalSensorMode::Daylight) == 1u, "enum value M_Common::OpticalSensorMode::Type::Daylight differs from the data model");
static_assert(std::is_same<::M_Common::OpticalSensorModeListType, std::vector<::M_Common::OpticalSensorMode::Type>>::value, "typedef M_Common::OpticalSensorModeListType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ZoomFactor::Zoom_0_25x) == 0u, "enum value M_Common::ZoomFactor::Type::Zoom_0_25x differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ZoomFactor::Zoom_0_5x) == 1u, "enum value M_Common::ZoomFactor::Type::Zoom_0_5x differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ZoomFactor::Zoom_1x) == 2u, "enum value M_Common::ZoomFactor::Type::Zoom_1x differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ZoomFactor::Zoom_2x) == 3u, "enum value M_Common::ZoomFactor::Type::Zoom_2x differs from the data model");
static_assert(std::is_same<::M_Common::ZoomFactorListType, std::vector<::M_Common::ZoomFactor::Type>>::value, "typedef M_Common::ZoomFactorListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::TimeType::Seconds), int64_t>::value, "M_Common::TimeType field Seconds differs from the data model");
static_assert(std::is_same<decltype(::M_Common::TimeType::Nanoseconds), int32_t>::value, "M_Common::TimeType field Nanoseconds differs from the data model");
static_assert(std::is_same<::M_Common::TimeOptionalType, std::vector<::M_Common::TimeType>>::value, "typedef M_Common::TimeOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::UnixTimeType, ::M_Common::TimeType>::value, "typedef M_Common::UnixTimeType differs from the data model");
static_assert(std::is_same<::M_Common::UnixTimeOptionalType, std::vector<::M_Common::TimeType>>::value, "typedef M_Common::UnixTimeOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::UtcType::UtcString), std::vector<std::string>>::value, "M_Common::UtcType field UtcString differs from the data model");
static_assert(std::is_same<decltype(::M_Common::UtcType::UnixTime), std::vector<::M_Common::TimeType>>::value, "M_Common::UtcType field UnixTime differs from the data model");
static_assert(std::is_same<decltype(::M_Common::UtcType::UtcOffsetMinutes), std::vector<int32_t>>::value, "M_Common::UtcType field UtcOffsetMinutes differs from the data model");
static_assert(std::is_same<decltype(::M_Common::UtcType::TimeStamp), std::vector<::M_Common::TimeType>>::value, "M_Common::UtcType field TimeStamp differs from the data model");
static_assert(std::is_same<::M_Common::UtcOptionalType, std::vector<::M_Common::UtcType>>::value, "typedef M_Common::UtcOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DurationType::DurationString), std::vector<std::string>>::value, "M_Common::DurationType field DurationString differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DurationType::DurationNumeric), std::vector<::M_Common::TimeType>>::value, "M_Common::DurationType field DurationNumeric differs from the data model");
static_assert(std::is_same<::M_Common::DurationOptionalType, std::vector<::M_Common::DurationType>>::value, "typedef M_Common::DurationOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::TimeIntervalType::StartTime), ::M_Common::TimeType>::value, "M_Common::TimeIntervalType field StartTime differs from the data model");
static_assert(std::is_same<decltype(::M_Common::TimeIntervalType::StopTime), ::M_Common::TimeType>::value, "M_Common::TimeIntervalType field StopTime differs from the data model");
static_assert(std::is_same<::M_Common::TimeIntervalOptionalType, std::vector<::M_Common::TimeIntervalType>>::value, "typedef M_Common::TimeIntervalOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::TimeIntervalListType, std::vector<::M_Common::TimeIntervalType>>::value, "typedef M_Common::TimeIntervalListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AxisDirectionType::X), double>::value, "M_Common::AxisDirectionType field X differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AxisDirectionType::Y), double>::value, "M_Common::AxisDirectionType field Y differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AxisDirectionType::Z), double>::value, "M_Common::AxisDirectionType field Z differs from the data model");
static_assert(std::is_same<::M_Common::AxisDirectionOptionalType, std::vector<::M_Common::AxisDirectionType>>::value, "typedef M_Common::AxisDirectionOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AxisScalarType::Vector), ::M_Common::AxisDirectionType>::value, "M_Common::AxisScalarType field Vector differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AxisScalarType::Scalar), double>::value, "M_Common::AxisScalarType field Scalar differs from the data model");
static_assert(std::is_same<::M_Common::AxisScalarOptionalType, std::vector<::M_Common::AxisScalarType>>::value, "typedef M_Common::AxisScalarOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::MagneticFluxDensityType::X), double>::value, "M_Common::MagneticFluxDensityType field X differs from the data model");
static_assert(std::is_same<decltype(::M_Common::MagneticFluxDensityType::Y), double>::value, "M_Common::MagneticFluxDensityType field Y differs from the data model");
static_assert(std::is_same<decltype(::M_Common::MagneticFluxDensityType::Z), double>::value, "M_Common::MagneticFluxDensityType field Z differs from the data model");
static_assert(std::is_same<::M_Common::MagneticFluxDensityOptionalType, std::vector<::M_Common::MagneticFluxDensityType>>::value, "typedef M_Common::MagneticFluxDensityOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::UncertaintyType::StandardDeviation), std::vector<double>>::value, "M_Common::UncertaintyType field StandardDeviation differs from the data model");
static_assert(std::is_same<decltype(::M_Common::UncertaintyType::EstimatedStandardError), std::vector<double>>::value, "M_Common::UncertaintyType field EstimatedStandardError differs from the data model");
static_assert(std::is_same<decltype(::M_Common::UncertaintyType::Covariance), std::vector<std::vector<double>>>::value, "M_Common::UncertaintyType field Covariance differs from the data model");
static_assert(std::is_same<decltype(::M_Common::UncertaintyType::ConfidenceRegion), std::vector<std::vector<double>>>::value, "M_Common::UncertaintyType field ConfidenceRegion differs from the data model");
static_assert(std::is_same<decltype(::M_Common::UncertaintyType::ConfidenceLevel), std::vector<double>>::value, "M_Common::UncertaintyType field ConfidenceLevel differs from the data model");
static_assert(std::is_same<::M_Common::UncertaintyOptionalType, std::vector<::M_Common::UncertaintyType>>::value, "typedef M_Common::UncertaintyOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianPositionType::X), double>::value, "M_Common::CartesianPositionType field X differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianPositionType::Y), double>::value, "M_Common::CartesianPositionType field Y differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianPositionType::Z), double>::value, "M_Common::CartesianPositionType field Z differs from the data model");
static_assert(std::is_same<::M_Common::CartesianPositionOptionalType, std::vector<::M_Common::CartesianPositionType>>::value, "typedef M_Common::CartesianPositionOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::CartesianPositionListType, std::vector<::M_Common::CartesianPositionType>>::value, "typedef M_Common::CartesianPositionListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalPositionType::Azimuth), double>::value, "M_Common::SphericalPositionType field Azimuth differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalPositionType::Elevation), double>::value, "M_Common::SphericalPositionType field Elevation differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalPositionType::Range), std::vector<double>>::value, "M_Common::SphericalPositionType field Range differs from the data model");
static_assert(std::is_same<::M_Common::SphericalPositionOptionalType, std::vector<::M_Common::SphericalPositionType>>::value, "typedef M_Common::SphericalPositionOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::SphericalPositionListType, std::vector<::M_Common::SphericalPositionType>>::value, "typedef M_Common::SphericalPositionListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EllipsoidalPositionType::Latitude), double>::value, "M_Common::EllipsoidalPositionType field Latitude differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EllipsoidalPositionType::Longitude), double>::value, "M_Common::EllipsoidalPositionType field Longitude differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EllipsoidalPositionType::Altitude), std::vector<double>>::value, "M_Common::EllipsoidalPositionType field Altitude differs from the data model");
static_assert(std::is_same<::M_Common::EllipsoidalPositionOptionalType, std::vector<::M_Common::EllipsoidalPositionType>>::value, "typedef M_Common::EllipsoidalPositionOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::EllipsoidalPositionListType, std::vector<::M_Common::EllipsoidalPositionType>>::value, "typedef M_Common::EllipsoidalPositionListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PositionType::Cartesian), std::vector<::M_Common::CartesianPositionType>>::value, "M_Common::PositionType field Cartesian differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PositionType::Spherical), std::vector<::M_Common::SphericalPositionType>>::value, "M_Common::PositionType field Spherical differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PositionType::Ellipsoidal), std::vector<::M_Common::EllipsoidalPositionType>>::value, "M_Common::PositionType field Ellipsoidal differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PositionType::CoordinateFrame), std::string>::value, "M_Common::PositionType field CoordinateFrame differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PositionType::Uncertainty), std::vector<::M_Common::UncertaintyType>>::value, "M_Common::PositionType field Uncertainty differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PositionType::Timestamp), std::vector<::M_Common::TimeType>>::value, "M_Common::PositionType field Timestamp differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PositionType::StorageMode), ::M_Common::StorageKind::Type>::value, "M_Common::PositionType field StorageMode differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PositionType::AdditionalInfo), std::vector<::M_Common::PropertyType>>::value, "M_Common::PositionType field AdditionalInfo differs from the data model");
static_assert(std::is_same<::M_Common::PositionOptionalType, std::vector<::M_Common::PositionType>>::value, "typedef M_Common::PositionOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::PositionListType, std::vector<::M_Common::PositionType>>::value, "typedef M_Common::PositionListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EulerAttitudeType::Roll), std::vector<double>>::value, "M_Common::EulerAttitudeType field Roll differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EulerAttitudeType::Pitch), std::vector<double>>::value, "M_Common::EulerAttitudeType field Pitch differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EulerAttitudeType::Yaw), std::vector<double>>::value, "M_Common::EulerAttitudeType field Yaw differs from the data model");
static_assert(std::is_same<::M_Common::EulerAttitudeOptionalType, std::vector<::M_Common::EulerAttitudeType>>::value, "typedef M_Common::EulerAttitudeOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AttitudeType::Euler), std::vector<::M_Common::EulerAttitudeType>>::value, "M_Common::AttitudeType field Euler differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AttitudeType::AxisScalar), std::vector<::M_Common::AxisScalarType>>::value, "M_Common::AttitudeType field AxisScalar differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AttitudeType::CoordinateFrame), std::string>::value, "M_Common::AttitudeType field CoordinateFrame differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AttitudeType::Uncertainty), std::vector<::M_Common::UncertaintyType>>::value, "M_Common::AttitudeType field Uncertainty differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AttitudeType::Timestamp), std::vector<::M_Common::TimeType>>::value, "M_Common::AttitudeType field Timestamp differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AttitudeType::StorageMode), ::M_Common::StorageKind::Type>::value, "M_Common::AttitudeType field StorageMode differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AttitudeType::AdditionalInfo), std::vector<::M_Common::PropertyType>>::value, "M_Common::AttitudeType field AdditionalInfo differs from the data model");
static_assert(std::is_same<::M_Common::AttitudeOptionalType, std::vector<::M_Common::AttitudeType>>::value, "typedef M_Common::AttitudeOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::AttitudeListType, std::vector<::M_Common::AttitudeType>>::value, "typedef M_Common::AttitudeListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianLinearVelocityType::X), double>::value, "M_Common::CartesianLinearVelocityType field X differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianLinearVelocityType::Y), double>::value, "M_Common::CartesianLinearVelocityType field Y differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianLinearVelocityType::Z), double>::value, "M_Common::CartesianLinearVelocityType field Z differs from the data model");
static_assert(std::is_same<::M_Common::CartesianLinearVelocityOptionalType, std::vector<::M_Common::CartesianLinearVelocityType>>::value, "typedef M_Common::CartesianLinearVelocityOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalLinearVelocityType::Azimuth), std::vector<double>>::value, "M_Common::SphericalLinearVelocityType field Azimuth differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalLinearVelocityType::Elevation), std::vector<double>>::value, "M_Common::SphericalLinearVelocityType field Elevation differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalLinearVelocityType::Speed), double>::value, "M_Common::SphericalLinearVelocityType field Speed differs from the data model");
static_assert(std::is_same<::M_Common::SphericalLinearVelocityOptionalType, std::vector<::M_Common::SphericalLinearVelocityType>>::value, "typedef M_Common::SphericalLinearVelocityOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalPositionRateType::AzimuthRate), double>::value, "M_Common::SphericalPositionRateType field AzimuthRate differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalPositionRateType::ElevationRate), double>::value, "M_Common::SphericalPositionRateType field ElevationRate differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalPositionRateType::RangeRate), std::vector<double>>::value, "M_Common::SphericalPositionRateType field RangeRate differs from the data model");
static_assert(std::is_same<::M_Common::SphericalPositionRateOptionalType, std::vector<::M_Common::SphericalPositionRateType>>::value, "typedef M_Common::SphericalPositionRateOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EllipsoidalPositionRateType::LatitudeRate), double>::value, "M_Common::EllipsoidalPositionRateType field LatitudeRate differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EllipsoidalPositionRateType::LongitudeRate), double>::value, "M_Common::EllipsoidalPositionRateType field LongitudeRate differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EllipsoidalPositionRateType::AltitudeRate), std::vector<double>>::value, "M_Common::EllipsoidalPositionRateType field AltitudeRate differs from the data model");
static_assert(std::is_same<::M_Common::EllipsoidalPositionRateOptionalType, std::vector<::M_Common::EllipsoidalPositionRateType>>::value, "typedef M_Common::EllipsoidalPositionRateOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocityType::Cartesian), std::vector<::M_Common::CartesianLinearVelocityType>>::value, "M_Common::LinearVelocityType field Cartesian differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocityType::Spherical), std::vector<::M_Common::SphericalLinearVelocityType>>::value, "M_Common::LinearVelocityType field Spherical differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocityType::SphericalPositionRate), std::vector<::M_Common::SphericalPositionRateType>>::value, "M_Common::LinearVelocityType field SphericalPositionRate differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocityType::EllipsoidalPositionRate), std::vector<::M_Common::EllipsoidalPositionRateType>>::value, "M_Common::LinearVelocityType field EllipsoidalPositionRate differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocityType::CoordinateFrame), std::string>::value, "M_Common::LinearVelocityType field CoordinateFrame differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocityType::Uncertainty), std::vector<::M_Common::UncertaintyType>>::value, "M_Common::LinearVelocityType field Uncertainty differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocityType::Timestamp), std::vector<::M_Common::TimeType>>::value, "M_Common::LinearVelocityType field Timestamp differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocityType::StorageMode), ::M_Common::StorageKind::Type>::value, "M_Common::LinearVelocityType field StorageMode differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocityType::AdditionalInfo), std::vector<::M_Common::PropertyType>>::value, "M_Common::LinearVelocityType field AdditionalInfo differs from the data model");
static_assert(std::is_same<::M_Common::LinearVelocityOptionalType, std::vector<::M_Common::LinearVelocityType>>::value, "typedef M_Common::LinearVelocityOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::LinearVelocityListType, std::vector<::M_Common::LinearVelocityType>>::value, "typedef M_Common::LinearVelocityListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianAngularVelocityType::X), std::vector<double>>::value, "M_Common::CartesianAngularVelocityType field X differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianAngularVelocityType::Y), std::vector<double>>::value, "M_Common::CartesianAngularVelocityType field Y differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianAngularVelocityType::Z), std::vector<double>>::value, "M_Common::CartesianAngularVelocityType field Z differs from the data model");
static_assert(std::is_same<::M_Common::CartesianAngularVelocityOptionalType, std::vector<::M_Common::CartesianAngularVelocityType>>::value, "typedef M_Common::CartesianAngularVelocityOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngularVelocityType::Cartesian), std::vector<::M_Common::CartesianAngularVelocityType>>::value, "M_Common::AngularVelocityType field Cartesian differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngularVelocityType::CoordinateFrame), std::string>::value, "M_Common::AngularVelocityType field CoordinateFrame differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngularVelocityType::Uncertainty), std::vector<::M_Common::UncertaintyType>>::value, "M_Common::AngularVelocityType field Uncertainty differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngularVelocityType::Timestamp), std::vector<::M_Common::TimeType>>::value, "M_Common::AngularVelocityType field Timestamp differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngularVelocityType::StorageMode), ::M_Common::StorageKind::Type>::value, "M_Common::AngularVelocityType field StorageMode differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngularVelocityType::AdditionalInfo), std::vector<::M_Common::PropertyType>>::value, "M_Common::AngularVelocityType field AdditionalInfo differs from the data model");
static_assert(std::is_same<::M_Common::AngularVelocityOptionalType, std::vector<::M_Common::AngularVelocityType>>::value, "typedef M_Common::AngularVelocityOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::AngularVelocityListType, std::vector<::M_Common::AngularVelocityType>>::value, "typedef M_Common::AngularVelocityListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianLinearAccelerationType::X), double>::value, "M_Common::CartesianLinearAccelerationType field X differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianLinearAccelerationType::Y), double>::value, "M_Common::CartesianLinearAccelerationType field Y differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianLinearAccelerationType::Z), double>::value, "M_Common::CartesianLinearAccelerationType field Z differs from the data model");
static_assert(std::is_same<::M_Common::CartesianLinearAccelerationOptionalType, std::vector<::M_Common::CartesianLinearAccelerationType>>::value, "typedef M_Common::CartesianLinearAccelerationOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearAccelerationType::Cartesian), std::vector<::M_Common::CartesianLinearAccelerationType>>::value, "M_Common::LinearAccelerationType field Cartesian differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearAccelerationType::CoordinateFrame), std::string>::value, "M_Common::LinearAccelerationType field CoordinateFrame differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearAccelerationType::Uncertainty), std::vector<::M_Common::UncertaintyType>>::value, "M_Common::LinearAccelerationType field Uncertainty differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearAccelerationType::Timestamp), std::vector<::M_Common::TimeType>>::value, "M_Common::LinearAccelerationType field Timestamp differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearAccelerationType::StorageMode), ::M_Common::StorageKind::Type>::value, "M_Common::LinearAccelerationType field StorageMode differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearAccelerationType::AdditionalInfo), std::vector<::M_Common::PropertyType>>::value, "M_Common::LinearAccelerationType field AdditionalInfo differs from the data model");
static_assert(std::is_same<::M_Common::LinearAccelerationOptionalType, std::vector<::M_Common::LinearAccelerationType>>::value, "typedef M_Common::LinearAccelerationOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::LinearAccelerationListType, std::vector<::M_Common::LinearAccelerationType>>::value, "typedef M_Common::LinearAccelerationListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianAngularAccelerationType::X), std::vector<double>>::value, "M_Common::CartesianAngularAccelerationType field X differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianAngularAccelerationType::Y), std::vector<double>>::value, "M_Common::CartesianAngularAccelerationType field Y differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianAngularAccelerationType::Z), std::vector<double>>::value, "M_Common::CartesianAngularAccelerationType field Z differs from the data model");
static_assert(std::is_same<::M_Common::CartesianAngularAccelerationOptionalType, std::vector<::M_Common::CartesianAngularAccelerationType>>::value, "typedef M_Common::CartesianAngularAccelerationOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngularAccelerationType::Cartesian), std::vector<::M_Common::CartesianAngularAccelerationType>>::value, "M_Common::AngularAccelerationType field Cartesian differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngularAccelerationType::CoordinateFrame), std::string>::value, "M_Common::AngularAccelerationType field CoordinateFrame differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngularAccelerationType::Uncertainty), std::vector<::M_Common::UncertaintyType>>::value, "M_Common::AngularAccelerationType field Uncertainty differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngularAccelerationType::Timestamp), std::vector<::M_Common::TimeType>>::value, "M_Common::AngularAccelerationType field Timestamp differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngularAccelerationType::StorageMode), ::M_Common::StorageKind::Type>::value, "M_Common::AngularAccelerationType field StorageMode differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngularAccelerationType::AdditionalInfo), std::vector<::M_Common::PropertyType>>::value, "M_Common::AngularAccelerationType field AdditionalInfo differs from the data model");
static_assert(std::is_same<::M_Common::AngularAccelerationOptionalType, std::vector<::M_Common::AngularAccelerationType>>::value, "typedef M_Common::AngularAccelerationOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::AngularAccelerationListType, std::vector<::M_Common::AngularAccelerationType>>::value, "typedef M_Common::AngularAccelerationListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CoordinateTransformationType::Target), std::string>::value, "M_Common::CoordinateTransformationType field Target differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CoordinateTransformationType::Source), std::vector<std::string>>::value, "M_Common::CoordinateTransformationType field Source differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CoordinateTransformationType::TransformationFromSourceToTarget), std::vector<std::vector<double>>>::value, "M_Common::CoordinateTransformationType field TransformationFromSourceToTarget differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CoordinateTransformationType::SourcePositionRelativeToTarget), std::vector<::M_Common::CartesianPositionType>>::value, "M_Common::CoordinateTransformationType field SourcePositionRelativeToTarget differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CoordinateTransformationType::SourceAttitudeRelativeToTarget), std::vector<::M_Common::EulerAttitudeType>>::value, "M_Common::CoordinateTransformationType field SourceAttitudeRelativeToTarget differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CoordinateTransformationType::Timestamp), std::vector<::M_Common::TimeType>>::value, "M_Common::CoordinateTransformationType field Timestamp differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CoordinateTransformationType::StorageMode), ::M_Common::StorageKind::Type>::value, "M_Common::CoordinateTransformationType field StorageMode differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CoordinateTransformationType::AdditionalInfo), std::vector<::M_Common::PropertyType>>::value, "M_Common::CoordinateTransformationType field AdditionalInfo differs from the data model");
static_assert(std::is_same<::M_Common::CoordinateTransformationListType, std::vector<::M_Common::CoordinateTransformationType>>::value, "typedef M_Common::CoordinateTransformationListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::MultiPositionType::Cartesian), std::vector<::M_Common::CartesianPositionType>>::value, "M_Common::MultiPositionType field Cartesian differs from the data model");
static_assert(std::is_same<decltype(::M_Common::MultiPositionType::Spherical), std::vector<::M_Common::SphericalPositionType>>::value, "M_Common::MultiPositionType field Spherical differs from the data model");
static_assert(std::is_same<decltype(::M_Common::MultiPositionType::Ellipsoidal), std::vector<::M_Common::EllipsoidalPositionType>>::value, "M_Common::MultiPositionType field Ellipsoidal differs from the data model");
static_assert(std::is_same<decltype(::M_Common::MultiPositionType::CoordinateFrame), std::string>::value, "M_Common::MultiPositionType field CoordinateFrame differs from the data model");
static_assert(std::is_same<decltype(::M_Common::MultiPositionType::StorageMode), ::M_Common::StorageKind::Type>::value, "M_Common::MultiPositionType field StorageMode differs from the data model");
static_assert(std::is_same<decltype(::M_Common::MultiPositionType::AdditionalInfo), std::vector<::M_Common::PropertyType>>::value, "M_Common::MultiPositionType field AdditionalInfo differs from the data model");
static_assert(std::is_same<::M_Common::MultiPositionOptionalType, std::vector<::M_Common::MultiPositionType>>::value, "typedef M_Common::MultiPositionOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::MultiPositionListType, std::vector<::M_Common::MultiPositionType>>::value, "typedef M_Common::MultiPositionListType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ImageKind::Bin) == 0u, "enum value M_Common::ImageKind::Type::Bin differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ImageKind::Raw8) == 1u, "enum value M_Common::ImageKind::Type::Raw8 differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ImageKind::Bmp) == 2u, "enum value M_Common::ImageKind::Type::Bmp differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ImageKind::Png) == 3u, "enum value M_Common::ImageKind::Type::Png differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ImageKind::Jpeg) == 4u, "enum value M_Common::ImageKind::Type::Jpeg differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ImageKind::Svg) == 5u, "enum value M_Common::ImageKind::Type::Svg differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PixelPoint2DType::X), uint32_t>::value, "M_Common::PixelPoint2DType field X differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PixelPoint2DType::Y), uint32_t>::value, "M_Common::PixelPoint2DType field Y differs from the data model");
static_assert(std::is_same<::M_Common::PixelPoint2DOptionalType, std::vector<::M_Common::PixelPoint2DType>>::value, "typedef M_Common::PixelPoint2DOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::PixelPoint2DListType, std::vector<::M_Common::PixelPoint2DType>>::value, "typedef M_Common::PixelPoint2DListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PixelOffsetType::X), int32_t>::value, "M_Common::PixelOffsetType field X differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PixelOffsetType::Y), int32_t>::value, "M_Common::PixelOffsetType field Y differs from the data model");
static_assert(std::is_same<::M_Common::PixelOffsetOptionalType, std::vector<::M_Common::PixelOffsetType>>::value, "typedef M_Common::PixelOffsetOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::PixelOffsetListType, std::vector<::M_Common::PixelOffsetType>>::value, "typedef M_Common::PixelOffsetListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PixelRectSizeType::Width), uint32_t>::value, "M_Common::PixelRectSizeType field Width differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PixelRectSizeType::Height), uint32_t>::value, "M_Common::PixelRectSizeType field Height differs from the data model");
static_assert(std::is_same<::M_Common::PixelRectSizeOptionalType, std::vector<::M_Common::PixelRectSizeType>>::value, "typedef M_Common::PixelRectSizeOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PixelRegionType::Offset), ::M_Common::PixelOffsetType>::value, "M_Common::PixelRegionType field Offset differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PixelRegionType::Size), ::M_Common::PixelRectSizeType>::value, "M_Common::PixelRegionType field Size differs from the data model");
static_assert(std::is_same<::M_Common::PixelRegionOptionalType, std::vector<::M_Common::PixelRegionType>>::value, "typedef M_Common::PixelRegionOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DegreeOffsetType::Azimuth), double>::value, "M_Common::DegreeOffsetType field Azimuth differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DegreeOffsetType::Elevation), double>::value, "M_Common::DegreeOffsetType field Elevation differs from the data model");
static_assert(std::is_same<::M_Common::DegreeOffsetOptionalType, std::vector<::M_Common::DegreeOffsetType>>::value, "typedef M_Common::DegreeOffsetOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::DegreeOffsetListType, std::vector<::M_Common::DegreeOffsetType>>::value, "typedef M_Common::DegreeOffsetListType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DegreeRectSizeType::Width), double>::value, "M_Common::DegreeRectSizeType field Width differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DegreeRectSizeType::Height), double>::value, "M_Common::DegreeRectSizeType field Height differs from the data model");
static_assert(std::is_same<::M_Common::DegreeRectSizeOptionalType, std::vector<::M_Common::DegreeRectSizeType>>::value, "typedef M_Common::DegreeRectSizeOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DegreeRegionType::Offset), ::M_Common::DegreeOffsetType>::value, "M_Common::DegreeRegionType field Offset differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DegreeRegionType::Size), ::M_Common::DegreeRectSizeType>::value, "M_Common::DegreeRegionType field Size differs from the data model");
static_assert(std::is_same<::M_Common::DegreeRegionOptionalType, std::vector<::M_Common::DegreeRegionType>>::value, "typedef M_Common::DegreeRegionOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ImageRegionType::RegionPixels), std::vector<::M_Common::PixelRegionType>>::value, "M_Common::ImageRegionType field RegionPixels differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ImageRegionType::RegionDegrees), std::vector<::M_Common::DegreeRegionType>>::value, "M_Common::ImageRegionType field RegionDegrees differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ImageRegionType::RotationAngle), std::vector<double>>::value, "M_Common::ImageRegionType field RotationAngle differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ImageType::Format), ::M_Common::ImageKind::Type>::value, "M_Common::ImageType field Format differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ImageType::Size), std::vector<::M_Common::PixelRectSizeType>>::value, "M_Common::ImageType field Size differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ImageType::Data), std::vector<uint8_t>>::value, "M_Common::ImageType field Data differs from the data model");
static_assert(std::is_same<::M_Common::ImageOptionalType, std::vector<::M_Common::ImageType>>::value, "typedef M_Common::ImageOptionalType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ColourScheme::Black_White) == 0u, "enum value M_Common::ColourScheme::Type::Black_White differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ColourScheme::Grayscale) == 1u, "enum value M_Common::ColourScheme::Type::Grayscale differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ColourScheme::RGB) == 2u, "enum value M_Common::ColourScheme::Type::RGB differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ColourScheme::HSL) == 3u, "enum value M_Common::ColourScheme::Type::HSL differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ColourScheme::HSV) == 4u, "enum value M_Common::ColourScheme::Type::HSV differs from the data model");
static_assert(std::is_same<::M_Common::ColourSchemeOptionalType, std::vector<::M_Common::ColourScheme::Type>>::value, "typedef M_Common::ColourSchemeOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ColourStyleType::ColourScheme), std::vector<::M_Common::ColourScheme::Type>>::value, "M_Common::ColourStyleType field ColourScheme differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ColourStyleType::ColourCode), std::vector<uint32_t>>::value, "M_Common::ColourStyleType field ColourCode differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ColourStyleType::Opacity), std::vector<double>>::value, "M_Common::ColourStyleType field Opacity differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ColourStyleType::Contrast), std::vector<double>>::value, "M_Common::ColourStyleType field Contrast differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ColourStyleType::Brightness), std::vector<double>>::value, "M_Common::ColourStyleType field Brightness differs from the data model");
static_assert(std::is_same<::M_Common::ColourStyleOptionalType, std::vector<::M_Common::ColourStyleType>>::value, "typedef M_Common::ColourStyleOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianDimensionsType::Width), std::vector<double>>::value, "M_Common::CartesianDimensionsType field Width differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianDimensionsType::Height), std::vector<double>>::value, "M_Common::CartesianDimensionsType field Height differs from the data model");
static_assert(std::is_same<decltype(::M_Common::CartesianDimensionsType::Length), std::vector<double>>::value, "M_Common::CartesianDimensionsType field Length differs from the data model");
static_assert(std::is_same<::M_Common::CartesianDimensionsOptionalType, std::vector<::M_Common::CartesianDimensionsType>>::value, "typedef M_Common::CartesianDimensionsOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalDimensionsType::Width), std::vector<double>>::value, "M_Common::SphericalDimensionsType field Width differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalDimensionsType::Height), std::vector<double>>::value, "M_Common::SphericalDimensionsType field Height differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalDimensionsType::Length), std::vector<double>>::value, "M_Common::SphericalDimensionsType field Length differs from the data model");
static_assert(std::is_same<::M_Common::SphericalDimensionsOptionalType, std::vector<::M_Common::SphericalDimensionsType>>::value, "typedef M_Common::SphericalDimensionsOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ObjectDimensionsType::Cartesian), std::vector<::M_Common::CartesianDimensionsType>>::value, "M_Common::ObjectDimensionsType field Cartesian differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ObjectDimensionsType::Spherical), std::vector<::M_Common::SphericalDimensionsType>>::value, "M_Common::ObjectDimensionsType field Spherical differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ObjectDimensionsType::Pixels), std::vector<::M_Common::PixelRectSizeType>>::value, "M_Common::ObjectDimensionsType field Pixels differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ObjectDimensionsType::RotationAngle), std::vector<double>>::value, "M_Common::ObjectDimensionsType field RotationAngle differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ObjectDimensionsType::Uncertainty), std::vector<::M_Common::UncertaintyType>>::value, "M_Common::ObjectDimensionsType field Uncertainty differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ObjectDimensionsType::CoordinateFrame), std::string>::value, "M_Common::ObjectDimensionsType field CoordinateFrame differs from the data model");
static_assert(std::is_same<::M_Common::ObjectDimensionsOptionalType, std::vector<::M_Common::ObjectDimensionsType>>::value, "typedef M_Common::ObjectDimensionsOptionalType differs from the data model");
static_assert(std::is_same<::M_Common::ObjectDimensionsListType, std::vector<::M_Common::ObjectDimensionsType>>::value, "typedef M_Common::ObjectDimensionsListType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ObjectRelationKind::Unknown) == 0u, "enum value M_Common::ObjectRelationKind::Type::Unknown differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ObjectRelationKind::DerivedFrom) == 1u, "enum value M_Common::ObjectRelationKind::Type::DerivedFrom differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ObjectRelationKind::Associated) == 2u, "enum value M_Common::ObjectRelationKind::Type::Associated differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ObjectRelationKind::PointOfOrigin) == 3u, "enum value M_Common::ObjectRelationKind::Type::PointOfOrigin differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ObjectRelationKind::PointOfDestination) == 4u, "enum value M_Common::ObjectRelationKind::Type::PointOfDestination differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ObjectRelationKind::ClusterComponent) == 5u, "enum value M_Common::ObjectRelationKind::Type::ClusterComponent differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ObjectRelationKind::TrackSplit) == 6u, "enum value M_Common::ObjectRelationKind::Type::TrackSplit differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ObjectRelationKind::TrackMerge) == 7u, "enum value M_Common::ObjectRelationKind::Type::TrackMerge differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::ObjectRelationKind::Duplicate) == 8u, "enum value M_Common::ObjectRelationKind::Type::Duplicate differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ObjectRelationType::Id), std::string>::value, "M_Common::ObjectRelationType field Id differs from the data model");
static_assert(std::is_same<decltype(::M_Common::ObjectRelationType::RelationKind), ::M_Common::ObjectRelationKind::Type>::value, "M_Common::ObjectRelationType field RelationKind differs from the data model");
static_assert(std::is_same<::M_Common::ObjectRelationListType, std::vector<::M_Common::ObjectRelationType>>::value, "typedef M_Common::ObjectRelationListType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::Availability::Unknown) == 0u, "enum value M_Common::Availability::Type::Unknown differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::Availability::Available) == 1u, "enum value M_Common::Availability::Type::Available differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::Availability::Reduced_Performance) == 2u, "enum value M_Common::Availability::Type::Reduced_Performance differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::Availability::Not_Available) == 3u, "enum value M_Common::Availability::Type::Not_Available differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::HorizontalDirection::None) == 0u, "enum value M_Common::HorizontalDirection::Type::None differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::HorizontalDirection::Right) == 1u, "enum value M_Common::HorizontalDirection::Type::Right differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::HorizontalDirection::Left) == 2u, "enum value M_Common::HorizontalDirection::Type::Left differs from the data model");
static_assert(std::is_same<::M_Common::HorizontalDirectionOptionalType, std::vector<::M_Common::HorizontalDirection::Type>>::value, "typedef M_Common::HorizontalDirectionOptionalType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::VerticalDirection::None) == 0u, "enum value M_Common::VerticalDirection::Type::None differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::VerticalDirection::Up) == 1u, "enum value M_Common::VerticalDirection::Type::Up differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::VerticalDirection::Down) == 2u, "enum value M_Common::VerticalDirection::Type::Down differs from the data model");
static_assert(std::is_same<::M_Common::VerticalDirectionOptionalType, std::vector<::M_Common::VerticalDirection::Type>>::value, "typedef M_Common::VerticalDirectionOptionalType differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::SelectedValueKind::Undefined) == 0u, "enum value M_Common::SelectedValueKind::Type::Undefined differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::SelectedValueKind::Fallback) == 1u, "enum value M_Common::SelectedValueKind::Type::Fallback differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::SelectedValueKind::Manual) == 2u, "enum value M_Common::SelectedValueKind::Type::Manual differs from the data model");
static_assert(static_cast<uint32_t>(::M_Common::SelectedValueKind::Auto) == 3u, "enum value M_Common::SelectedValueKind::Type::Auto differs from the data model");
static_assert(std::is_same<decltype(::M_Common::TemperatureKelvinsSelectionType::DefaultValue), std::vector<double>>::value, "M_Common::TemperatureKelvinsSelectionType field DefaultValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::TemperatureKelvinsSelectionType::ManualValue), std::vector<double>>::value, "M_Common::TemperatureKelvinsSelectionType field ManualValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::TemperatureKelvinsSelectionType::AutoValue), std::vector<double>>::value, "M_Common::TemperatureKelvinsSelectionType field AutoValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::TemperatureKelvinsSelectionType::ActiveSelection), ::M_Common::SelectedValueKind::Type>::value, "M_Common::TemperatureKelvinsSelectionType field ActiveSelection differs from the data model");
static_assert(std::is_same<::M_Common::TemperatureKelvinsSelectionOptionalType, std::vector<::M_Common::TemperatureKelvinsSelectionType>>::value, "typedef M_Common::TemperatureKelvinsSelectionOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PressurePascalsSelectionType::DefaultValue), std::vector<double>>::value, "M_Common::PressurePascalsSelectionType field DefaultValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PressurePascalsSelectionType::ManualValue), std::vector<double>>::value, "M_Common::PressurePascalsSelectionType field ManualValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PressurePascalsSelectionType::AutoValue), std::vector<double>>::value, "M_Common::PressurePascalsSelectionType field AutoValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PressurePascalsSelectionType::ActiveSelection), ::M_Common::SelectedValueKind::Type>::value, "M_Common::PressurePascalsSelectionType field ActiveSelection differs from the data model");
static_assert(std::is_same<::M_Common::PressurePascalsSelectionOptionalType, std::vector<::M_Common::PressurePascalsSelectionType>>::value, "typedef M_Common::PressurePascalsSelectionOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PercentSelectionType::DefaultValue), std::vector<double>>::value, "M_Common::PercentSelectionType field DefaultValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PercentSelectionType::ManualValue), std::vector<double>>::value, "M_Common::PercentSelectionType field ManualValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PercentSelectionType::AutoValue), std::vector<double>>::value, "M_Common::PercentSelectionType field AutoValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::PercentSelectionType::ActiveSelection), ::M_Common::SelectedValueKind::Type>::value, "M_Common::PercentSelectionType field ActiveSelection differs from the data model");
static_assert(std::is_same<::M_Common::PercentSelectionOptionalType, std::vector<::M_Common::PercentSelectionType>>::value, "typedef M_Common::PercentSelectionOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocitySelectionType::DefaultValue), std::vector<::M_Common::LinearVelocityType>>::value, "M_Common::LinearVelocitySelectionType field DefaultValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocitySelectionType::ManualValue), std::vector<::M_Common::LinearVelocityType>>::value, "M_Common::LinearVelocitySelectionType field ManualValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocitySelectionType::AutoValue), std::vector<::M_Common::LinearVelocityType>>::value, "M_Common::LinearVelocitySelectionType field AutoValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::LinearVelocitySelectionType::ActiveSelection), ::M_Common::SelectedValueKind::Type>::value, "M_Common::LinearVelocitySelectionType field ActiveSelection differs from the data model");
static_assert(std::is_same<::M_Common::LinearVelocitySelectionOptionalType, std::vector<::M_Common::LinearVelocitySelectionType>>::value, "typedef M_Common::LinearVelocitySelectionOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DistanceMetersSelectionType::SourceId), std::vector<std::string>>::value, "M_Common::DistanceMetersSelectionType field SourceId differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DistanceMetersSelectionType::DefaultValue), std::vector<double>>::value, "M_Common::DistanceMetersSelectionType field DefaultValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DistanceMetersSelectionType::ManualValue), std::vector<double>>::value, "M_Common::DistanceMetersSelectionType field ManualValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DistanceMetersSelectionType::AutoValue), std::vector<double>>::value, "M_Common::DistanceMetersSelectionType field AutoValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::DistanceMetersSelectionType::ActiveSelection), ::M_Common::SelectedValueKind::Type>::value, "M_Common::DistanceMetersSelectionType field ActiveSelection differs from the data model");
static_assert(std::is_same<::M_Common::DistanceMetersSelectionOptionalType, std::vector<::M_Common::DistanceMetersSelectionType>>::value, "typedef M_Common::DistanceMetersSelectionOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EulerAttitudeSelectionType::DefaultValue), std::vector<::M_Common::EulerAttitudeType>>::value, "M_Common::EulerAttitudeSelectionType field DefaultValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EulerAttitudeSelectionType::ManualValue), std::vector<::M_Common::EulerAttitudeType>>::value, "M_Common::EulerAttitudeSelectionType field ManualValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EulerAttitudeSelectionType::AutoValue), std::vector<::M_Common::EulerAttitudeType>>::value, "M_Common::EulerAttitudeSelectionType field AutoValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EulerAttitudeSelectionType::ActiveSelection), ::M_Common::SelectedValueKind::Type>::value, "M_Common::EulerAttitudeSelectionType field ActiveSelection differs from the data model");
static_assert(std::is_same<::M_Common::EulerAttitudeSelectionOptionalType, std::vector<::M_Common::EulerAttitudeSelectionType>>::value, "typedef M_Common::EulerAttitudeSelectionOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngleRateDegreesPerSecSelectionType::DefaultValue), std::vector<double>>::value, "M_Common::AngleRateDegreesPerSecSelectionType field DefaultValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngleRateDegreesPerSecSelectionType::ManualValue), std::vector<double>>::value, "M_Common::AngleRateDegreesPerSecSelectionType field ManualValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngleRateDegreesPerSecSelectionType::AutoValue), std::vector<double>>::value, "M_Common::AngleRateDegreesPerSecSelectionType field AutoValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::AngleRateDegreesPerSecSelectionType::ActiveSelection), ::M_Common::SelectedValueKind::Type>::value, "M_Common::AngleRateDegreesPerSecSelectionType field ActiveSelection differs from the data model");
static_assert(std::is_same<::M_Common::AngleRateDegreesPerSecSelectionOptionalType, std::vector<::M_Common::AngleRateDegreesPerSecSelectionType>>::value, "typedef M_Common::AngleRateDegreesPerSecSelectionOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalPositionRateSelectionType::DefaultValue), std::vector<::M_Common::SphericalPositionRateType>>::value, "M_Common::SphericalPositionRateSelectionType field DefaultValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalPositionRateSelectionType::ManualValue), std::vector<::M_Common::SphericalPositionRateType>>::value, "M_Common::SphericalPositionRateSelectionType field ManualValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalPositionRateSelectionType::AutoValue), std::vector<::M_Common::SphericalPositionRateType>>::value, "M_Common::SphericalPositionRateSelectionType field AutoValue differs from the data model");
static_assert(std::is_same<decltype(::M_Common::SphericalPositionRateSelectionType::ActiveSelection), ::M_Common::SelectedValueKind::Type>::value, "M_Common::SphericalPositionRateSelectionType field ActiveSelection differs from the data model");
static_assert(std::is_same<::M_Common::SphericalPositionRateSelectionOptionalType, std::vector<::M_Common::SphericalPositionRateSelectionType>>::value, "typedef M_Common::SphericalPositionRateSelectionOptionalType differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EncryptionType::Algorithm), std::string>::value, "M_Common::EncryptionType field Algorithm differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EncryptionType::Token), std::vector<uint8_t>>::value, "M_Common::EncryptionType field Token differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EncryptionType::Aad), std::vector<uint8_t>>::value, "M_Common::EncryptionType field Aad differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EncryptionType::Iv), std::vector<uint8_t>>::value, "M_Common::EncryptionType field Iv differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EncryptionType::Mac), std::vector<uint8_t>>::value, "M_Common::EncryptionType field Mac differs from the data model");
static_assert(std::is_same<decltype(::M_Common::EncryptionType::Nounce), std::vector<uint8_t>>::value, "M_Common::EncryptionType field Nounce differs from the data model");
static_assert(std::is_same<::M_Common::EncryptionOptionalType, std::vector<::M_Common::EncryptionType>>::value, "typedef M_Common::EncryptionOptionalType differs from the data model");
namespace M_Common {
void obapi_put(::obapi::Writer& w, ObjectClassificationType const& v) {
::obapi::put(w, v.Category);
::obapi::put(w, v.AbstractionLayer);
::obapi::put(w, v.Confidence);
::obapi::put(w, v.Priority);
}
void obapi_get(::obapi::Reader& r, ObjectClassificationType& v) {
::obapi::get(r, v.Category);
::obapi::get(r, v.AbstractionLayer);
::obapi::get(r, v.Confidence);
::obapi::get(r, v.Priority);
}
void obapi_put(::obapi::Writer& w, PropertyType const& v) {
::obapi::put(w, v.Name);
::obapi::put(w, v.StrValue);
::obapi::put(w, v.DoubleValue);
::obapi::put(w, v.LongValue);
::obapi::put(w, v.AccessMode);
}
void obapi_get(::obapi::Reader& r, PropertyType& v) {
::obapi::get(r, v.Name);
::obapi::get(r, v.StrValue);
::obapi::get(r, v.DoubleValue);
::obapi::get(r, v.LongValue);
::obapi::get(r, v.AccessMode);
}
void obapi_put(::obapi::Writer& w, OperationModeType const& v) {
::obapi::put(w, v.Name);
::obapi::put(w, v.EnumeratedValue);
::obapi::put(w, v.IntegerValue);
::obapi::put(w, v.TextualValue);
::obapi::put(w, v.TransitionState);
::obapi::put(w, v.AdditionalInfo);
}
void obapi_get(::obapi::Reader& r, OperationModeType& v) {
::obapi::get(r, v.Name);
::obapi::get(r, v.EnumeratedValue);
::obapi::get(r, v.IntegerValue);
::obapi::get(r, v.TextualValue);
::obapi::get(r, v.TransitionState);
::obapi::get(r, v.AdditionalInfo);
}
void obapi_put(::obapi::Writer& w, OperationFaultType const& v) {
::obapi::put(w, v.Name);
::obapi::put(w, v.EnumeratedValue);
::obapi::put(w, v.IntegerValue);
::obapi::put(w, v.TextualValue);
}
void obapi_get(::obapi::Reader& r, OperationFaultType& v) {
::obapi::get(r, v.Name);
::obapi::get(r, v.EnumeratedValue);
::obapi::get(r, v.IntegerValue);
::obapi::get(r, v.TextualValue);
}
void obapi_put(::obapi::Writer& w, ModeTransitionInfoType const& v) {
::obapi::put(w, v.LastState);
::obapi::put(w, v.RequestedState);
::obapi::put(w, v.Errors);
}
void obapi_get(::obapi::Reader& r, ModeTransitionInfoType& v) {
::obapi::get(r, v.LastState);
::obapi::get(r, v.RequestedState);
::obapi::get(r, v.Errors);
}
void obapi_put(::obapi::Writer& w, OperationStatusType const& v) {
::obapi::put(w, v.Mode);
::obapi::put(w, v.ModeTransitionInfo);
::obapi::put(w, v.PermittedModeTransitionList);
::obapi::put(w, v.SubmodeList);
::obapi::put(w, v.Faults);
}
void obapi_get(::obapi::Reader& r, OperationStatusType& v) {
::obapi::get(r, v.Mode);
::obapi::get(r, v.ModeTransitionInfo);
::obapi::get(r, v.PermittedModeTransitionList);
::obapi::get(r, v.SubmodeList);
::obapi::get(r, v.Faults);
}
void obapi_put(::obapi::Writer& w, TimeType const& v) {
::obapi::put(w, v.Seconds);
::obapi::put(w, v.Nanoseconds);
}
void obapi_get(::obapi::Reader& r, TimeType& v) {
::obapi::get(r, v.Seconds);
::obapi::get(r, v.Nanoseconds);
}
void obapi_put(::obapi::Writer& w, UtcType const& v) {
::obapi::put(w, v.UtcString);
::obapi::put(w, v.UnixTime);
::obapi::put(w, v.UtcOffsetMinutes);
::obapi::put(w, v.TimeStamp);
}
void obapi_get(::obapi::Reader& r, UtcType& v) {
::obapi::get(r, v.UtcString);
::obapi::get(r, v.UnixTime);
::obapi::get(r, v.UtcOffsetMinutes);
::obapi::get(r, v.TimeStamp);
}
void obapi_put(::obapi::Writer& w, DurationType const& v) {
::obapi::put(w, v.DurationString);
::obapi::put(w, v.DurationNumeric);
}
void obapi_get(::obapi::Reader& r, DurationType& v) {
::obapi::get(r, v.DurationString);
::obapi::get(r, v.DurationNumeric);
}
void obapi_put(::obapi::Writer& w, TimeIntervalType const& v) {
::obapi::put(w, v.StartTime);
::obapi::put(w, v.StopTime);
}
void obapi_get(::obapi::Reader& r, TimeIntervalType& v) {
::obapi::get(r, v.StartTime);
::obapi::get(r, v.StopTime);
}
void obapi_put(::obapi::Writer& w, AxisDirectionType const& v) {
::obapi::put(w, v.X);
::obapi::put(w, v.Y);
::obapi::put(w, v.Z);
}
void obapi_get(::obapi::Reader& r, AxisDirectionType& v) {
::obapi::get(r, v.X);
::obapi::get(r, v.Y);
::obapi::get(r, v.Z);
}
void obapi_put(::obapi::Writer& w, AxisScalarType const& v) {
::obapi::put(w, v.Vector);
::obapi::put(w, v.Scalar);
}
void obapi_get(::obapi::Reader& r, AxisScalarType& v) {
::obapi::get(r, v.Vector);
::obapi::get(r, v.Scalar);
}
void obapi_put(::obapi::Writer& w, MagneticFluxDensityType const& v) {
::obapi::put(w, v.X);
::obapi::put(w, v.Y);
::obapi::put(w, v.Z);
}
void obapi_get(::obapi::Reader& r, MagneticFluxDensityType& v) {
::obapi::get(r, v.X);
::obapi::get(r, v.Y);
::obapi::get(r, v.Z);
}
void obapi_put(::obapi::Writer& w, UncertaintyType const& v) {
::obapi::put(w, v.StandardDeviation);
::obapi::put(w, v.EstimatedStandardError);
::obapi::put(w, v.Covariance);
::obapi::put(w, v.ConfidenceRegion);
::obapi::put(w, v.ConfidenceLevel);
}
void obapi_get(::obapi::Reader& r, UncertaintyType& v) {
::obapi::get(r, v.StandardDeviation);
::obapi::get(r, v.EstimatedStandardError);
::obapi::get(r, v.Covariance);
::obapi::get(r, v.ConfidenceRegion);
::obapi::get(r, v.ConfidenceLevel);
}
void obapi_put(::obapi::Writer& w, CartesianPositionType const& v) {
::obapi::put(w, v.X);
::obapi::put(w, v.Y);
::obapi::put(w, v.Z);
}
void obapi_get(::obapi::Reader& r, CartesianPositionType& v) {
::obapi::get(r, v.X);
::obapi::get(r, v.Y);
::obapi::get(r, v.Z);
}
void obapi_put(::obapi::Writer& w, SphericalPositionType const& v) {
::obapi::put(w, v.Azimuth);
::obapi::put(w, v.Elevation);
::obapi::put(w, v.Range);
}
void obapi_get(::obapi::Reader& r, SphericalPositionType& v) {
::obapi::get(r, v.Azimuth);
::obapi::get(r, v.Elevation);
::obapi::get(r, v.Range);
}
void obapi_put(::obapi::Writer& w, EllipsoidalPositionType const& v) {
::obapi::put(w, v.Latitude);
::obapi::put(w, v.Longitude);
::obapi::put(w, v.Altitude);
}
void obapi_get(::obapi::Reader& r, EllipsoidalPositionType& v) {
::obapi::get(r, v.Latitude);
::obapi::get(r, v.Longitude);
::obapi::get(r, v.Altitude);
}
void obapi_put(::obapi::Writer& w, PositionType const& v) {
::obapi::put(w, v.Cartesian);
::obapi::put(w, v.Spherical);
::obapi::put(w, v.Ellipsoidal);
::obapi::put(w, v.CoordinateFrame);
::obapi::put(w, v.Uncertainty);
::obapi::put(w, v.Timestamp);
::obapi::put(w, v.StorageMode);
::obapi::put(w, v.AdditionalInfo);
}
void obapi_get(::obapi::Reader& r, PositionType& v) {
::obapi::get(r, v.Cartesian);
::obapi::get(r, v.Spherical);
::obapi::get(r, v.Ellipsoidal);
::obapi::get(r, v.CoordinateFrame);
::obapi::get(r, v.Uncertainty);
::obapi::get(r, v.Timestamp);
::obapi::get(r, v.StorageMode);
::obapi::get(r, v.AdditionalInfo);
}
void obapi_put(::obapi::Writer& w, EulerAttitudeType const& v) {
::obapi::put(w, v.Roll);
::obapi::put(w, v.Pitch);
::obapi::put(w, v.Yaw);
}
void obapi_get(::obapi::Reader& r, EulerAttitudeType& v) {
::obapi::get(r, v.Roll);
::obapi::get(r, v.Pitch);
::obapi::get(r, v.Yaw);
}
void obapi_put(::obapi::Writer& w, AttitudeType const& v) {
::obapi::put(w, v.Euler);
::obapi::put(w, v.AxisScalar);
::obapi::put(w, v.CoordinateFrame);
::obapi::put(w, v.Uncertainty);
::obapi::put(w, v.Timestamp);
::obapi::put(w, v.StorageMode);
::obapi::put(w, v.AdditionalInfo);
}
void obapi_get(::obapi::Reader& r, AttitudeType& v) {
::obapi::get(r, v.Euler);
::obapi::get(r, v.AxisScalar);
::obapi::get(r, v.CoordinateFrame);
::obapi::get(r, v.Uncertainty);
::obapi::get(r, v.Timestamp);
::obapi::get(r, v.StorageMode);
::obapi::get(r, v.AdditionalInfo);
}
void obapi_put(::obapi::Writer& w, CartesianLinearVelocityType const& v) {
::obapi::put(w, v.X);
::obapi::put(w, v.Y);
::obapi::put(w, v.Z);
}
void obapi_get(::obapi::Reader& r, CartesianLinearVelocityType& v) {
::obapi::get(r, v.X);
::obapi::get(r, v.Y);
::obapi::get(r, v.Z);
}
void obapi_put(::obapi::Writer& w, SphericalLinearVelocityType const& v) {
::obapi::put(w, v.Azimuth);
::obapi::put(w, v.Elevation);
::obapi::put(w, v.Speed);
}
void obapi_get(::obapi::Reader& r, SphericalLinearVelocityType& v) {
::obapi::get(r, v.Azimuth);
::obapi::get(r, v.Elevation);
::obapi::get(r, v.Speed);
}
void obapi_put(::obapi::Writer& w, SphericalPositionRateType const& v) {
::obapi::put(w, v.AzimuthRate);
::obapi::put(w, v.ElevationRate);
::obapi::put(w, v.RangeRate);
}
void obapi_get(::obapi::Reader& r, SphericalPositionRateType& v) {
::obapi::get(r, v.AzimuthRate);
::obapi::get(r, v.ElevationRate);
::obapi::get(r, v.RangeRate);
}
void obapi_put(::obapi::Writer& w, EllipsoidalPositionRateType const& v) {
::obapi::put(w, v.LatitudeRate);
::obapi::put(w, v.LongitudeRate);
::obapi::put(w, v.AltitudeRate);
}
void obapi_get(::obapi::Reader& r, EllipsoidalPositionRateType& v) {
::obapi::get(r, v.LatitudeRate);
::obapi::get(r, v.LongitudeRate);
::obapi::get(r, v.AltitudeRate);
}
void obapi_put(::obapi::Writer& w, LinearVelocityType const& v) {
::obapi::put(w, v.Cartesian);
::obapi::put(w, v.Spherical);
::obapi::put(w, v.SphericalPositionRate);
::obapi::put(w, v.EllipsoidalPositionRate);
::obapi::put(w, v.CoordinateFrame);
::obapi::put(w, v.Uncertainty);
::obapi::put(w, v.Timestamp);
::obapi::put(w, v.StorageMode);
::obapi::put(w, v.AdditionalInfo);
}
void obapi_get(::obapi::Reader& r, LinearVelocityType& v) {
::obapi::get(r, v.Cartesian);
::obapi::get(r, v.Spherical);
::obapi::get(r, v.SphericalPositionRate);
::obapi::get(r, v.EllipsoidalPositionRate);
::obapi::get(r, v.CoordinateFrame);
::obapi::get(r, v.Uncertainty);
::obapi::get(r, v.Timestamp);
::obapi::get(r, v.StorageMode);
::obapi::get(r, v.AdditionalInfo);
}
void obapi_put(::obapi::Writer& w, CartesianAngularVelocityType const& v) {
::obapi::put(w, v.X);
::obapi::put(w, v.Y);
::obapi::put(w, v.Z);
}
void obapi_get(::obapi::Reader& r, CartesianAngularVelocityType& v) {
::obapi::get(r, v.X);
::obapi::get(r, v.Y);
::obapi::get(r, v.Z);
}
void obapi_put(::obapi::Writer& w, AngularVelocityType const& v) {
::obapi::put(w, v.Cartesian);
::obapi::put(w, v.CoordinateFrame);
::obapi::put(w, v.Uncertainty);
::obapi::put(w, v.Timestamp);
::obapi::put(w, v.StorageMode);
::obapi::put(w, v.AdditionalInfo);
}
void obapi_get(::obapi::Reader& r, AngularVelocityType& v) {
::obapi::get(r, v.Cartesian);
::obapi::get(r, v.CoordinateFrame);
::obapi::get(r, v.Uncertainty);
::obapi::get(r, v.Timestamp);
::obapi::get(r, v.StorageMode);
::obapi::get(r, v.AdditionalInfo);
}
void obapi_put(::obapi::Writer& w, CartesianLinearAccelerationType const& v) {
::obapi::put(w, v.X);
::obapi::put(w, v.Y);
::obapi::put(w, v.Z);
}
void obapi_get(::obapi::Reader& r, CartesianLinearAccelerationType& v) {
::obapi::get(r, v.X);
::obapi::get(r, v.Y);
::obapi::get(r, v.Z);
}
void obapi_put(::obapi::Writer& w, LinearAccelerationType const& v) {
::obapi::put(w, v.Cartesian);
::obapi::put(w, v.CoordinateFrame);
::obapi::put(w, v.Uncertainty);
::obapi::put(w, v.Timestamp);
::obapi::put(w, v.StorageMode);
::obapi::put(w, v.AdditionalInfo);
}
void obapi_get(::obapi::Reader& r, LinearAccelerationType& v) {
::obapi::get(r, v.Cartesian);
::obapi::get(r, v.CoordinateFrame);
::obapi::get(r, v.Uncertainty);
::obapi::get(r, v.Timestamp);
::obapi::get(r, v.StorageMode);
::obapi::get(r, v.AdditionalInfo);
}
void obapi_put(::obapi::Writer& w, CartesianAngularAccelerationType const& v) {
::obapi::put(w, v.X);
::obapi::put(w, v.Y);
::obapi::put(w, v.Z);
}
void obapi_get(::obapi::Reader& r, CartesianAngularAccelerationType& v) {
::obapi::get(r, v.X);
::obapi::get(r, v.Y);
::obapi::get(r, v.Z);
}
void obapi_put(::obapi::Writer& w, AngularAccelerationType const& v) {
::obapi::put(w, v.Cartesian);
::obapi::put(w, v.CoordinateFrame);
::obapi::put(w, v.Uncertainty);
::obapi::put(w, v.Timestamp);
::obapi::put(w, v.StorageMode);
::obapi::put(w, v.AdditionalInfo);
}
void obapi_get(::obapi::Reader& r, AngularAccelerationType& v) {
::obapi::get(r, v.Cartesian);
::obapi::get(r, v.CoordinateFrame);
::obapi::get(r, v.Uncertainty);
::obapi::get(r, v.Timestamp);
::obapi::get(r, v.StorageMode);
::obapi::get(r, v.AdditionalInfo);
}
void obapi_put(::obapi::Writer& w, CoordinateTransformationType const& v) {
::obapi::put(w, v.Target);
::obapi::put(w, v.Source);
::obapi::put(w, v.TransformationFromSourceToTarget);
::obapi::put(w, v.SourcePositionRelativeToTarget);
::obapi::put(w, v.SourceAttitudeRelativeToTarget);
::obapi::put(w, v.Timestamp);
::obapi::put(w, v.StorageMode);
::obapi::put(w, v.AdditionalInfo);
}
void obapi_get(::obapi::Reader& r, CoordinateTransformationType& v) {
::obapi::get(r, v.Target);
::obapi::get(r, v.Source);
::obapi::get(r, v.TransformationFromSourceToTarget);
::obapi::get(r, v.SourcePositionRelativeToTarget);
::obapi::get(r, v.SourceAttitudeRelativeToTarget);
::obapi::get(r, v.Timestamp);
::obapi::get(r, v.StorageMode);
::obapi::get(r, v.AdditionalInfo);
}
void obapi_put(::obapi::Writer& w, MultiPositionType const& v) {
::obapi::put(w, v.Cartesian);
::obapi::put(w, v.Spherical);
::obapi::put(w, v.Ellipsoidal);
::obapi::put(w, v.CoordinateFrame);
::obapi::put(w, v.StorageMode);
::obapi::put(w, v.AdditionalInfo);
}
void obapi_get(::obapi::Reader& r, MultiPositionType& v) {
::obapi::get(r, v.Cartesian);
::obapi::get(r, v.Spherical);
::obapi::get(r, v.Ellipsoidal);
::obapi::get(r, v.CoordinateFrame);
::obapi::get(r, v.StorageMode);
::obapi::get(r, v.AdditionalInfo);
}
void obapi_put(::obapi::Writer& w, PixelPoint2DType const& v) {
::obapi::put(w, v.X);
::obapi::put(w, v.Y);
}
void obapi_get(::obapi::Reader& r, PixelPoint2DType& v) {
::obapi::get(r, v.X);
::obapi::get(r, v.Y);
}
void obapi_put(::obapi::Writer& w, PixelOffsetType const& v) {
::obapi::put(w, v.X);
::obapi::put(w, v.Y);
}
void obapi_get(::obapi::Reader& r, PixelOffsetType& v) {
::obapi::get(r, v.X);
::obapi::get(r, v.Y);
}
void obapi_put(::obapi::Writer& w, PixelRectSizeType const& v) {
::obapi::put(w, v.Width);
::obapi::put(w, v.Height);
}
void obapi_get(::obapi::Reader& r, PixelRectSizeType& v) {
::obapi::get(r, v.Width);
::obapi::get(r, v.Height);
}
void obapi_put(::obapi::Writer& w, PixelRegionType const& v) {
::obapi::put(w, v.Offset);
::obapi::put(w, v.Size);
}
void obapi_get(::obapi::Reader& r, PixelRegionType& v) {
::obapi::get(r, v.Offset);
::obapi::get(r, v.Size);
}
void obapi_put(::obapi::Writer& w, DegreeOffsetType const& v) {
::obapi::put(w, v.Azimuth);
::obapi::put(w, v.Elevation);
}
void obapi_get(::obapi::Reader& r, DegreeOffsetType& v) {
::obapi::get(r, v.Azimuth);
::obapi::get(r, v.Elevation);
}
void obapi_put(::obapi::Writer& w, DegreeRectSizeType const& v) {
::obapi::put(w, v.Width);
::obapi::put(w, v.Height);
}
void obapi_get(::obapi::Reader& r, DegreeRectSizeType& v) {
::obapi::get(r, v.Width);
::obapi::get(r, v.Height);
}
void obapi_put(::obapi::Writer& w, DegreeRegionType const& v) {
::obapi::put(w, v.Offset);
::obapi::put(w, v.Size);
}
void obapi_get(::obapi::Reader& r, DegreeRegionType& v) {
::obapi::get(r, v.Offset);
::obapi::get(r, v.Size);
}
void obapi_put(::obapi::Writer& w, ImageRegionType const& v) {
::obapi::put(w, v.RegionPixels);
::obapi::put(w, v.RegionDegrees);
::obapi::put(w, v.RotationAngle);
}
void obapi_get(::obapi::Reader& r, ImageRegionType& v) {
::obapi::get(r, v.RegionPixels);
::obapi::get(r, v.RegionDegrees);
::obapi::get(r, v.RotationAngle);
}
void obapi_put(::obapi::Writer& w, ImageType const& v) {
::obapi::put(w, v.Format);
::obapi::put(w, v.Size);
::obapi::put(w, v.Data);
}
void obapi_get(::obapi::Reader& r, ImageType& v) {
::obapi::get(r, v.Format);
::obapi::get(r, v.Size);
::obapi::get(r, v.Data);
}
void obapi_put(::obapi::Writer& w, ColourStyleType const& v) {
::obapi::put(w, v.ColourScheme);
::obapi::put(w, v.ColourCode);
::obapi::put(w, v.Opacity);
::obapi::put(w, v.Contrast);
::obapi::put(w, v.Brightness);
}
void obapi_get(::obapi::Reader& r, ColourStyleType& v) {
::obapi::get(r, v.ColourScheme);
::obapi::get(r, v.ColourCode);
::obapi::get(r, v.Opacity);
::obapi::get(r, v.Contrast);
::obapi::get(r, v.Brightness);
}
void obapi_put(::obapi::Writer& w, CartesianDimensionsType const& v) {
::obapi::put(w, v.Width);
::obapi::put(w, v.Height);
::obapi::put(w, v.Length);
}
void obapi_get(::obapi::Reader& r, CartesianDimensionsType& v) {
::obapi::get(r, v.Width);
::obapi::get(r, v.Height);
::obapi::get(r, v.Length);
}
void obapi_put(::obapi::Writer& w, SphericalDimensionsType const& v) {
::obapi::put(w, v.Width);
::obapi::put(w, v.Height);
::obapi::put(w, v.Length);
}
void obapi_get(::obapi::Reader& r, SphericalDimensionsType& v) {
::obapi::get(r, v.Width);
::obapi::get(r, v.Height);
::obapi::get(r, v.Length);
}
void obapi_put(::obapi::Writer& w, ObjectDimensionsType const& v) {
::obapi::put(w, v.Cartesian);
::obapi::put(w, v.Spherical);
::obapi::put(w, v.Pixels);
::obapi::put(w, v.RotationAngle);
::obapi::put(w, v.Uncertainty);
::obapi::put(w, v.CoordinateFrame);
}
void obapi_get(::obapi::Reader& r, ObjectDimensionsType& v) {
::obapi::get(r, v.Cartesian);
::obapi::get(r, v.Spherical);
::obapi::get(r, v.Pixels);
::obapi::get(r, v.RotationAngle);
::obapi::get(r, v.Uncertainty);
::obapi::get(r, v.CoordinateFrame);
}
void obapi_put(::obapi::Writer& w, ObjectRelationType const& v) {
::obapi::put(w, v.Id);
::obapi::put(w, v.RelationKind);
}
void obapi_get(::obapi::Reader& r, ObjectRelationType& v) {
::obapi::get(r, v.Id);
::obapi::get(r, v.RelationKind);
}
void obapi_put(::obapi::Writer& w, TemperatureKelvinsSelectionType const& v) {
::obapi::put(w, v.DefaultValue);
::obapi::put(w, v.ManualValue);
::obapi::put(w, v.AutoValue);
::obapi::put(w, v.ActiveSelection);
}
void obapi_get(::obapi::Reader& r, TemperatureKelvinsSelectionType& v) {
::obapi::get(r, v.DefaultValue);
::obapi::get(r, v.ManualValue);
::obapi::get(r, v.AutoValue);
::obapi::get(r, v.ActiveSelection);
}
void obapi_put(::obapi::Writer& w, PressurePascalsSelectionType const& v) {
::obapi::put(w, v.DefaultValue);
::obapi::put(w, v.ManualValue);
::obapi::put(w, v.AutoValue);
::obapi::put(w, v.ActiveSelection);
}
void obapi_get(::obapi::Reader& r, PressurePascalsSelectionType& v) {
::obapi::get(r, v.DefaultValue);
::obapi::get(r, v.ManualValue);
::obapi::get(r, v.AutoValue);
::obapi::get(r, v.ActiveSelection);
}
void obapi_put(::obapi::Writer& w, PercentSelectionType const& v) {
::obapi::put(w, v.DefaultValue);
::obapi::put(w, v.ManualValue);
::obapi::put(w, v.AutoValue);
::obapi::put(w, v.ActiveSelection);
}
void obapi_get(::obapi::Reader& r, PercentSelectionType& v) {
::obapi::get(r, v.DefaultValue);
::obapi::get(r, v.ManualValue);
::obapi::get(r, v.AutoValue);
::obapi::get(r, v.ActiveSelection);
}
void obapi_put(::obapi::Writer& w, LinearVelocitySelectionType const& v) {
::obapi::put(w, v.DefaultValue);
::obapi::put(w, v.ManualValue);
::obapi::put(w, v.AutoValue);
::obapi::put(w, v.ActiveSelection);
}
void obapi_get(::obapi::Reader& r, LinearVelocitySelectionType& v) {
::obapi::get(r, v.DefaultValue);
::obapi::get(r, v.ManualValue);
::obapi::get(r, v.AutoValue);
::obapi::get(r, v.ActiveSelection);
}
void obapi_put(::obapi::Writer& w, DistanceMetersSelectionType const& v) {
::obapi::put(w, v.SourceId);
::obapi::put(w, v.DefaultValue);
::obapi::put(w, v.ManualValue);
::obapi::put(w, v.AutoValue);
::obapi::put(w, v.ActiveSelection);
}
void obapi_get(::obapi::Reader& r, DistanceMetersSelectionType& v) {
::obapi::get(r, v.SourceId);
::obapi::get(r, v.DefaultValue);
::obapi::get(r, v.ManualValue);
::obapi::get(r, v.AutoValue);
::obapi::get(r, v.ActiveSelection);
}
void obapi_put(::obapi::Writer& w, EulerAttitudeSelectionType const& v) {
::obapi::put(w, v.DefaultValue);
::obapi::put(w, v.ManualValue);
::obapi::put(w, v.AutoValue);
::obapi::put(w, v.ActiveSelection);
}
void obapi_get(::obapi::Reader& r, EulerAttitudeSelectionType& v) {
::obapi::get(r, v.DefaultValue);
::obapi::get(r, v.ManualValue);
::obapi::get(r, v.AutoValue);
::obapi::get(r, v.ActiveSelection);
}
void obapi_put(::obapi::Writer& w, AngleRateDegreesPerSecSelectionType const& v) {
::obapi::put(w, v.DefaultValue);
::obapi::put(w, v.ManualValue);
::obapi::put(w, v.AutoValue);
::obapi::put(w, v.ActiveSelection);
}
void obapi_get(::obapi::Reader& r, AngleRateDegreesPerSecSelectionType& v) {
::obapi::get(r, v.DefaultValue);
::obapi::get(r, v.ManualValue);
::obapi::get(r, v.AutoValue);
::obapi::get(r, v.ActiveSelection);
}
void obapi_put(::obapi::Writer& w, SphericalPositionRateSelectionType const& v) {
::obapi::put(w, v.DefaultValue);
::obapi::put(w, v.ManualValue);
::obapi::put(w, v.AutoValue);
::obapi::put(w, v.ActiveSelection);
}
void obapi_get(::obapi::Reader& r, SphericalPositionRateSelectionType& v) {
::obapi::get(r, v.DefaultValue);
::obapi::get(r, v.ManualValue);
::obapi::get(r, v.AutoValue);
::obapi::get(r, v.ActiveSelection);
}
void obapi_put(::obapi::Writer& w, EncryptionType const& v) {
::obapi::put(w, v.Algorithm);
::obapi::put(w, v.Token);
::obapi::put(w, v.Aad);
::obapi::put(w, v.Iv);
::obapi::put(w, v.Mac);
::obapi::put(w, v.Nounce);
}
void obapi_get(::obapi::Reader& r, EncryptionType& v) {
::obapi::get(r, v.Algorithm);
::obapi::get(r, v.Token);
::obapi::get(r, v.Aad);
::obapi::get(r, v.Iv);
::obapi::get(r, v.Mac);
::obapi::get(r, v.Nounce);
}
}