/**
  * Json <-> DDS conversion routines
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Christian Ehrlicher, SLSE, 2017-11-30
  */


// filename: tab_json.h
#pragma once

#include "tab.hpp"
#include "tab_export.h"

#include <QJsonObject>
#include <QJsonValue>

namespace TrainingAreaBase
{
template<typename T>
struct type{};

template<typename T>
T fromJson(const QJsonValue &val, type<T>);

template<typename T>
T fromJson(const QJsonValue &val)
{
  return fromJson(val, type<T>{});
}


// BatteryAlarm
TAB_COMMON_EXPORT QJsonObject toJson(const BatteryAlarm &element);
template<> TAB_COMMON_EXPORT BatteryAlarm fromJson(const QJsonValue &val, type<BatteryAlarm>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< BatteryAlarm > &element);
template<> TAB_COMMON_EXPORT std::vector<BatteryAlarm> fromJson(const QJsonValue &value, type< std::vector< BatteryAlarm > >);


// BatteryInfo
TAB_COMMON_EXPORT QJsonObject toJson(const BatteryInfo &element);
template<> TAB_COMMON_EXPORT BatteryInfo fromJson(const QJsonValue &val, type<BatteryInfo>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< BatteryInfo > &element);
template<> TAB_COMMON_EXPORT std::vector<BatteryInfo> fromJson(const QJsonValue &value, type< std::vector< BatteryInfo > >);


// BatteryState
TAB_COMMON_EXPORT QJsonObject toJson(const BatteryState &element);
template<> TAB_COMMON_EXPORT BatteryState fromJson(const QJsonValue &val, type<BatteryState>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< BatteryState > &element);
template<> TAB_COMMON_EXPORT std::vector<BatteryState> fromJson(const QJsonValue &value, type< std::vector< BatteryState > >);


// ConnectionState
TAB_COMMON_EXPORT QJsonObject toJson(const ConnectionState &element);
template<> TAB_COMMON_EXPORT ConnectionState fromJson(const QJsonValue &val, type<ConnectionState>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< ConnectionState > &element);
template<> TAB_COMMON_EXPORT std::vector<ConnectionState> fromJson(const QJsonValue &value, type< std::vector< ConnectionState > >);


// Connections
TAB_COMMON_EXPORT QJsonObject toJson(const Connections &element);
template<> TAB_COMMON_EXPORT Connections fromJson(const QJsonValue &val, type<Connections>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< Connections > &element);
template<> TAB_COMMON_EXPORT std::vector<Connections> fromJson(const QJsonValue &value, type< std::vector< Connections > >);


// Core::GeoPosition
TAB_COMMON_EXPORT QJsonObject toJson(const Core::GeoPosition &element);
template<> TAB_COMMON_EXPORT Core::GeoPosition fromJson(const QJsonValue &val, type<Core::GeoPosition>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< Core::GeoPosition > &element);
template<> TAB_COMMON_EXPORT std::vector<Core::GeoPosition> fromJson(const QJsonValue &value, type< std::vector< Core::GeoPosition > >);


// Core::GeoPosition2D
TAB_COMMON_EXPORT QJsonObject toJson(const Core::GeoPosition2D &element);
template<> TAB_COMMON_EXPORT Core::GeoPosition2D fromJson(const QJsonValue &val, type<Core::GeoPosition2D>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< Core::GeoPosition2D > &element);
template<> TAB_COMMON_EXPORT std::vector<Core::GeoPosition2D> fromJson(const QJsonValue &value, type< std::vector< Core::GeoPosition2D > >);


// Core::GeoPositionRelativeTime
TAB_COMMON_EXPORT QJsonObject toJson(const Core::GeoPositionRelativeTime &element);
template<> TAB_COMMON_EXPORT Core::GeoPositionRelativeTime fromJson(const QJsonValue &val, type<Core::GeoPositionRelativeTime>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< Core::GeoPositionRelativeTime > &element);
template<> TAB_COMMON_EXPORT std::vector<Core::GeoPositionRelativeTime> fromJson(const QJsonValue &value, type< std::vector< Core::GeoPositionRelativeTime > >);


// Core::Orientation
TAB_COMMON_EXPORT QJsonObject toJson(const Core::Orientation &element);
template<> TAB_COMMON_EXPORT Core::Orientation fromJson(const QJsonValue &val, type<Core::Orientation>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< Core::Orientation > &element);
template<> TAB_COMMON_EXPORT std::vector<Core::Orientation> fromJson(const QJsonValue &value, type< std::vector< Core::Orientation > >);


// Core::RelativePosition
TAB_COMMON_EXPORT QJsonObject toJson(const Core::RelativePosition &element);
template<> TAB_COMMON_EXPORT Core::RelativePosition fromJson(const QJsonValue &val, type<Core::RelativePosition>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< Core::RelativePosition > &element);
template<> TAB_COMMON_EXPORT std::vector<Core::RelativePosition> fromJson(const QJsonValue &value, type< std::vector< Core::RelativePosition > >);


// CtaDataError
TAB_COMMON_EXPORT QJsonObject toJson(const CtaDataError &element);
template<> TAB_COMMON_EXPORT CtaDataError fromJson(const QJsonValue &val, type<CtaDataError>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< CtaDataError > &element);
template<> TAB_COMMON_EXPORT std::vector<CtaDataError> fromJson(const QJsonValue &value, type< std::vector< CtaDataError > >);


// DefinitionIed
TAB_COMMON_EXPORT QJsonObject toJson(const DefinitionIed &element);
template<> TAB_COMMON_EXPORT DefinitionIed fromJson(const QJsonValue &val, type<DefinitionIed>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< DefinitionIed > &element);
template<> TAB_COMMON_EXPORT std::vector<DefinitionIed> fromJson(const QJsonValue &value, type< std::vector< DefinitionIed > >);


// Dispersion
TAB_COMMON_EXPORT QJsonObject toJson(const Dispersion &element);
template<> TAB_COMMON_EXPORT Dispersion fromJson(const QJsonValue &val, type<Dispersion>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< Dispersion > &element);
template<> TAB_COMMON_EXPORT std::vector<Dispersion> fromJson(const QJsonValue &value, type< std::vector< Dispersion > >);


// DusSingleMineState
TAB_COMMON_EXPORT QJsonObject toJson(const DusSingleMineState &element);
template<> TAB_COMMON_EXPORT DusSingleMineState fromJson(const QJsonValue &val, type<DusSingleMineState>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< DusSingleMineState > &element);
template<> TAB_COMMON_EXPORT std::vector<DusSingleMineState> fromJson(const QJsonValue &value, type< std::vector< DusSingleMineState > >);


// EX_CeaseFiring
TAB_COMMON_EXPORT QJsonObject toJson(const EX_CeaseFiring &element);
template<> TAB_COMMON_EXPORT EX_CeaseFiring fromJson(const QJsonValue &val, type<EX_CeaseFiring>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EX_CeaseFiring > &element);
template<> TAB_COMMON_EXPORT std::vector<EX_CeaseFiring> fromJson(const QJsonValue &value, type< std::vector< EX_CeaseFiring > >);


// EX_DoNotFire
TAB_COMMON_EXPORT QJsonObject toJson(const EX_DoNotFire &element);
template<> TAB_COMMON_EXPORT EX_DoNotFire fromJson(const QJsonValue &val, type<EX_DoNotFire>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EX_DoNotFire > &element);
template<> TAB_COMMON_EXPORT std::vector<EX_DoNotFire> fromJson(const QJsonValue &value, type< std::vector< EX_DoNotFire > >);


// EX_ExplorationResult
TAB_COMMON_EXPORT QJsonObject toJson(const EX_ExplorationResult &element);
template<> TAB_COMMON_EXPORT EX_ExplorationResult fromJson(const QJsonValue &val, type<EX_ExplorationResult>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EX_ExplorationResult > &element);
template<> TAB_COMMON_EXPORT std::vector<EX_ExplorationResult> fromJson(const QJsonValue &value, type< std::vector< EX_ExplorationResult > >);


// EX_Fire
TAB_COMMON_EXPORT QJsonObject toJson(const EX_Fire &element);
template<> TAB_COMMON_EXPORT EX_Fire fromJson(const QJsonValue &val, type<EX_Fire>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EX_Fire > &element);
template<> TAB_COMMON_EXPORT std::vector<EX_Fire> fromJson(const QJsonValue &value, type< std::vector< EX_Fire > >);


// EX_GuidingLines
TAB_COMMON_EXPORT QJsonObject toJson(const EX_GuidingLines &element);
template<> TAB_COMMON_EXPORT EX_GuidingLines fromJson(const QJsonValue &val, type<EX_GuidingLines>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EX_GuidingLines > &element);
template<> TAB_COMMON_EXPORT std::vector<EX_GuidingLines> fromJson(const QJsonValue &value, type< std::vector< EX_GuidingLines > >);


// EX_GuidingLinesAndBoundaries
TAB_COMMON_EXPORT QJsonObject toJson(const EX_GuidingLinesAndBoundaries &element);
template<> TAB_COMMON_EXPORT EX_GuidingLinesAndBoundaries fromJson(const QJsonValue &val, type<EX_GuidingLinesAndBoundaries>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EX_GuidingLinesAndBoundaries > &element);
template<> TAB_COMMON_EXPORT std::vector<EX_GuidingLinesAndBoundaries> fromJson(const QJsonValue &value, type< std::vector< EX_GuidingLinesAndBoundaries > >);


// EX_MessageRevocation
TAB_COMMON_EXPORT QJsonObject toJson(const EX_MessageRevocation &element);
template<> TAB_COMMON_EXPORT EX_MessageRevocation fromJson(const QJsonValue &val, type<EX_MessageRevocation>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EX_MessageRevocation > &element);
template<> TAB_COMMON_EXPORT std::vector<EX_MessageRevocation> fromJson(const QJsonValue &value, type< std::vector< EX_MessageRevocation > >);


// EX_ReportEffectorUnit
TAB_COMMON_EXPORT QJsonObject toJson(const EX_ReportEffectorUnit &element);
template<> TAB_COMMON_EXPORT EX_ReportEffectorUnit fromJson(const QJsonValue &val, type<EX_ReportEffectorUnit>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EX_ReportEffectorUnit > &element);
template<> TAB_COMMON_EXPORT std::vector<EX_ReportEffectorUnit> fromJson(const QJsonValue &value, type< std::vector< EX_ReportEffectorUnit > >);


// EX_StartFiring
TAB_COMMON_EXPORT QJsonObject toJson(const EX_StartFiring &element);
template<> TAB_COMMON_EXPORT EX_StartFiring fromJson(const QJsonValue &val, type<EX_StartFiring>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EX_StartFiring > &element);
template<> TAB_COMMON_EXPORT std::vector<EX_StartFiring> fromJson(const QJsonValue &value, type< std::vector< EX_StartFiring > >);


// EmergencyCall
TAB_COMMON_EXPORT QJsonObject toJson(const EmergencyCall &element);
template<> TAB_COMMON_EXPORT EmergencyCall fromJson(const QJsonValue &val, type<EmergencyCall>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EmergencyCall > &element);
template<> TAB_COMMON_EXPORT std::vector<EmergencyCall> fromJson(const QJsonValue &value, type< std::vector< EmergencyCall > >);


// Equipment
TAB_COMMON_EXPORT QJsonObject toJson(const Equipment &element);
template<> TAB_COMMON_EXPORT Equipment fromJson(const QJsonValue &val, type<Equipment>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< Equipment > &element);
template<> TAB_COMMON_EXPORT std::vector<Equipment> fromJson(const QJsonValue &value, type< std::vector< Equipment > >);


// EquipmentBase
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentBase &element);
template<> TAB_COMMON_EXPORT EquipmentBase fromJson(const QJsonValue &val, type<EquipmentBase>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentBase > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentBase> fromJson(const QJsonValue &value, type< std::vector< EquipmentBase > >);


// EquipmentBite
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentBite &element);
template<> TAB_COMMON_EXPORT EquipmentBite fromJson(const QJsonValue &val, type<EquipmentBite>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentBite > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentBite> fromJson(const QJsonValue &value, type< std::vector< EquipmentBite > >);


// EquipmentBiteError
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentBiteError &element);
template<> TAB_COMMON_EXPORT EquipmentBiteError fromJson(const QJsonValue &val, type<EquipmentBiteError>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentBiteError > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentBiteError> fromJson(const QJsonValue &value, type< std::vector< EquipmentBiteError > >);


// EquipmentConfigurationReport
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentConfigurationReport &element);
template<> TAB_COMMON_EXPORT EquipmentConfigurationReport fromJson(const QJsonValue &val, type<EquipmentConfigurationReport>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentConfigurationReport > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentConfigurationReport> fromJson(const QJsonValue &value, type< std::vector< EquipmentConfigurationReport > >);


// EquipmentEvent
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentEvent &element);
template<> TAB_COMMON_EXPORT EquipmentEvent fromJson(const QJsonValue &val, type<EquipmentEvent>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentEvent > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentEvent> fromJson(const QJsonValue &value, type< std::vector< EquipmentEvent > >);


// EquipmentGearAssignment
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentGearAssignment &element);
template<> TAB_COMMON_EXPORT EquipmentGearAssignment fromJson(const QJsonValue &val, type<EquipmentGearAssignment>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentGearAssignment > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentGearAssignment> fromJson(const QJsonValue &value, type< std::vector< EquipmentGearAssignment > >);


// EquipmentGearChargeState
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentGearChargeState &element);
template<> TAB_COMMON_EXPORT EquipmentGearChargeState fromJson(const QJsonValue &val, type<EquipmentGearChargeState>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentGearChargeState > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentGearChargeState> fromJson(const QJsonValue &value, type< std::vector< EquipmentGearChargeState > >);


// EquipmentGearEvent
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentGearEvent &element);
template<> TAB_COMMON_EXPORT EquipmentGearEvent fromJson(const QJsonValue &val, type<EquipmentGearEvent>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentGearEvent > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentGearEvent> fromJson(const QJsonValue &value, type< std::vector< EquipmentGearEvent > >);


// EquipmentMessage
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentMessage &element);
template<> TAB_COMMON_EXPORT EquipmentMessage fromJson(const QJsonValue &val, type<EquipmentMessage>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentMessage > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentMessage> fromJson(const QJsonValue &value, type< std::vector< EquipmentMessage > >);


// EquipmentOperationalState
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentOperationalState &element);
template<> TAB_COMMON_EXPORT EquipmentOperationalState fromJson(const QJsonValue &val, type<EquipmentOperationalState>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentOperationalState > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentOperationalState> fromJson(const QJsonValue &value, type< std::vector< EquipmentOperationalState > >);


// EquipmentPosition
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentPosition &element);
template<> TAB_COMMON_EXPORT EquipmentPosition fromJson(const QJsonValue &val, type<EquipmentPosition>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentPosition > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentPosition> fromJson(const QJsonValue &value, type< std::vector< EquipmentPosition > >);


// EquipmentState
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentState &element);
template<> TAB_COMMON_EXPORT EquipmentState fromJson(const QJsonValue &val, type<EquipmentState>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentState > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentState> fromJson(const QJsonValue &value, type< std::vector< EquipmentState > >);


// EquipmentSwVersion
TAB_COMMON_EXPORT QJsonObject toJson(const EquipmentSwVersion &element);
template<> TAB_COMMON_EXPORT EquipmentSwVersion fromJson(const QJsonValue &val, type<EquipmentSwVersion>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< EquipmentSwVersion > &element);
template<> TAB_COMMON_EXPORT std::vector<EquipmentSwVersion> fromJson(const QJsonValue &value, type< std::vector< EquipmentSwVersion > >);


// ExAwesPlanning
TAB_COMMON_EXPORT QJsonObject toJson(const ExAwesPlanning &element);
template<> TAB_COMMON_EXPORT ExAwesPlanning fromJson(const QJsonValue &val, type<ExAwesPlanning>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< ExAwesPlanning > &element);
template<> TAB_COMMON_EXPORT std::vector<ExAwesPlanning> fromJson(const QJsonValue &value, type< std::vector< ExAwesPlanning > >);


// ExReportEffector
TAB_COMMON_EXPORT QJsonObject toJson(const ExReportEffector &element);
template<> TAB_COMMON_EXPORT ExReportEffector fromJson(const QJsonValue &val, type<ExReportEffector>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< ExReportEffector > &element);
template<> TAB_COMMON_EXPORT std::vector<ExReportEffector> fromJson(const QJsonValue &value, type< std::vector< ExReportEffector > >);


// Ex_ReconResults
TAB_COMMON_EXPORT QJsonObject toJson(const Ex_ReconResults &element);
template<> TAB_COMMON_EXPORT Ex_ReconResults fromJson(const QJsonValue &val, type<Ex_ReconResults>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< Ex_ReconResults > &element);
template<> TAB_COMMON_EXPORT std::vector<Ex_ReconResults> fromJson(const QJsonValue &value, type< std::vector< Ex_ReconResults > >);


// Ex_ReportSupplyZone
TAB_COMMON_EXPORT QJsonObject toJson(const Ex_ReportSupplyZone &element);
template<> TAB_COMMON_EXPORT Ex_ReportSupplyZone fromJson(const QJsonValue &val, type<Ex_ReportSupplyZone>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< Ex_ReportSupplyZone > &element);
template<> TAB_COMMON_EXPORT std::vector<Ex_ReportSupplyZone> fromJson(const QJsonValue &value, type< std::vector< Ex_ReportSupplyZone > >);


// FireSmokeMarkerData
TAB_COMMON_EXPORT QJsonObject toJson(const FireSmokeMarkerData &element);
template<> TAB_COMMON_EXPORT FireSmokeMarkerData fromJson(const QJsonValue &val, type<FireSmokeMarkerData>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< FireSmokeMarkerData > &element);
template<> TAB_COMMON_EXPORT std::vector<FireSmokeMarkerData> fromJson(const QJsonValue &value, type< std::vector< FireSmokeMarkerData > >);


// FunctionalAreaEntry
TAB_COMMON_EXPORT QJsonObject toJson(const FunctionalAreaEntry &element);
template<> TAB_COMMON_EXPORT FunctionalAreaEntry fromJson(const QJsonValue &val, type<FunctionalAreaEntry>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< FunctionalAreaEntry > &element);
template<> TAB_COMMON_EXPORT std::vector<FunctionalAreaEntry> fromJson(const QJsonValue &value, type< std::vector< FunctionalAreaEntry > >);


// Gear
TAB_COMMON_EXPORT QJsonObject toJson(const Gear &element);
template<> TAB_COMMON_EXPORT Gear fromJson(const QJsonValue &val, type<Gear>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< Gear > &element);
template<> TAB_COMMON_EXPORT std::vector<Gear> fromJson(const QJsonValue &value, type< std::vector< Gear > >);


// GearCharge
TAB_COMMON_EXPORT QJsonObject toJson(const GearCharge &element);
template<> TAB_COMMON_EXPORT GearCharge fromJson(const QJsonValue &val, type<GearCharge>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< GearCharge > &element);
template<> TAB_COMMON_EXPORT std::vector<GearCharge> fromJson(const QJsonValue &value, type< std::vector< GearCharge > >);


// GeopairingData
TAB_COMMON_EXPORT QJsonObject toJson(const GeopairingData &element);
template<> TAB_COMMON_EXPORT GeopairingData fromJson(const QJsonValue &val, type<GeopairingData>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< GeopairingData > &element);
template<> TAB_COMMON_EXPORT std::vector<GeopairingData> fromJson(const QJsonValue &value, type< std::vector< GeopairingData > >);


// IedBaseData
TAB_COMMON_EXPORT QJsonObject toJson(const IedBaseData &element);
template<> TAB_COMMON_EXPORT IedBaseData fromJson(const QJsonValue &val, type<IedBaseData>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< IedBaseData > &element);
template<> TAB_COMMON_EXPORT std::vector<IedBaseData> fromJson(const QJsonValue &value, type< std::vector< IedBaseData > >);


// L12_TargetData
TAB_COMMON_EXPORT QJsonObject toJson(const L12_TargetData &element);
template<> TAB_COMMON_EXPORT L12_TargetData fromJson(const QJsonValue &val, type<L12_TargetData>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L12_TargetData > &element);
template<> TAB_COMMON_EXPORT std::vector<L12_TargetData> fromJson(const QJsonValue &value, type< std::vector< L12_TargetData > >);


// L13_EffectorUnit
TAB_COMMON_EXPORT QJsonObject toJson(const L13_EffectorUnit &element);
template<> TAB_COMMON_EXPORT L13_EffectorUnit fromJson(const QJsonValue &val, type<L13_EffectorUnit>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L13_EffectorUnit > &element);
template<> TAB_COMMON_EXPORT std::vector<L13_EffectorUnit> fromJson(const QJsonValue &value, type< std::vector< L13_EffectorUnit > >);


// L18_EffectableArea
TAB_COMMON_EXPORT QJsonObject toJson(const L18_EffectableArea &element);
template<> TAB_COMMON_EXPORT L18_EffectableArea fromJson(const QJsonValue &val, type<L18_EffectableArea>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L18_EffectableArea > &element);
template<> TAB_COMMON_EXPORT std::vector<L18_EffectableArea> fromJson(const QJsonValue &value, type< std::vector< L18_EffectableArea > >);


// L29_ReconnaissanceUnit
TAB_COMMON_EXPORT QJsonObject toJson(const L29_ReconnaissanceUnit &element);
template<> TAB_COMMON_EXPORT L29_ReconnaissanceUnit fromJson(const QJsonValue &val, type<L29_ReconnaissanceUnit>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L29_ReconnaissanceUnit > &element);
template<> TAB_COMMON_EXPORT std::vector<L29_ReconnaissanceUnit> fromJson(const QJsonValue &value, type< std::vector< L29_ReconnaissanceUnit > >);


// L30_reconnaissancePositionArea
TAB_COMMON_EXPORT QJsonObject toJson(const L30_reconnaissancePositionArea &element);
template<> TAB_COMMON_EXPORT L30_reconnaissancePositionArea fromJson(const QJsonValue &val, type<L30_reconnaissancePositionArea>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L30_reconnaissancePositionArea > &element);
template<> TAB_COMMON_EXPORT std::vector<L30_reconnaissancePositionArea> fromJson(const QJsonValue &value, type< std::vector< L30_reconnaissancePositionArea > >);


// L31_MailAddress
TAB_COMMON_EXPORT QJsonObject toJson(const L31_MailAddress &element);
template<> TAB_COMMON_EXPORT L31_MailAddress fromJson(const QJsonValue &val, type<L31_MailAddress>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L31_MailAddress > &element);
template<> TAB_COMMON_EXPORT std::vector<L31_MailAddress> fromJson(const QJsonValue &value, type< std::vector< L31_MailAddress > >);


// L33_FireCommand
TAB_COMMON_EXPORT QJsonObject toJson(const L33_FireCommand &element);
template<> TAB_COMMON_EXPORT L33_FireCommand fromJson(const QJsonValue &val, type<L33_FireCommand>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L33_FireCommand > &element);
template<> TAB_COMMON_EXPORT std::vector<L33_FireCommand> fromJson(const QJsonValue &value, type< std::vector< L33_FireCommand > >);


// L34_effector
TAB_COMMON_EXPORT QJsonObject toJson(const L34_effector &element);
template<> TAB_COMMON_EXPORT L34_effector fromJson(const QJsonValue &val, type<L34_effector>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L34_effector > &element);
template<> TAB_COMMON_EXPORT std::vector<L34_effector> fromJson(const QJsonValue &value, type< std::vector< L34_effector > >);


// L35_TrajectoryPoint
TAB_COMMON_EXPORT QJsonObject toJson(const L35_TrajectoryPoint &element);
template<> TAB_COMMON_EXPORT L35_TrajectoryPoint fromJson(const QJsonValue &val, type<L35_TrajectoryPoint>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L35_TrajectoryPoint > &element);
template<> TAB_COMMON_EXPORT std::vector<L35_TrajectoryPoint> fromJson(const QJsonValue &value, type< std::vector< L35_TrajectoryPoint > >);


// L36_FiringCommandCharges
TAB_COMMON_EXPORT QJsonObject toJson(const L36_FiringCommandCharges &element);
template<> TAB_COMMON_EXPORT L36_FiringCommandCharges fromJson(const QJsonValue &val, type<L36_FiringCommandCharges>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L36_FiringCommandCharges > &element);
template<> TAB_COMMON_EXPORT std::vector<L36_FiringCommandCharges> fromJson(const QJsonValue &value, type< std::vector< L36_FiringCommandCharges > >);


// L39_ScatteringData
TAB_COMMON_EXPORT QJsonObject toJson(const L39_ScatteringData &element);
template<> TAB_COMMON_EXPORT L39_ScatteringData fromJson(const QJsonValue &val, type<L39_ScatteringData>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L39_ScatteringData > &element);
template<> TAB_COMMON_EXPORT std::vector<L39_ScatteringData> fromJson(const QJsonValue &value, type< std::vector< L39_ScatteringData > >);


// L3_Unit
TAB_COMMON_EXPORT QJsonObject toJson(const L3_Unit &element);
template<> TAB_COMMON_EXPORT L3_Unit fromJson(const QJsonValue &val, type<L3_Unit>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L3_Unit > &element);
template<> TAB_COMMON_EXPORT std::vector<L3_Unit> fromJson(const QJsonValue &value, type< std::vector< L3_Unit > >);


// L8_Charges
TAB_COMMON_EXPORT QJsonObject toJson(const L8_Charges &element);
template<> TAB_COMMON_EXPORT L8_Charges fromJson(const QJsonValue &val, type<L8_Charges>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< L8_Charges > &element);
template<> TAB_COMMON_EXPORT std::vector<L8_Charges> fromJson(const QJsonValue &value, type< std::vector< L8_Charges > >);


// LaserDesignation
TAB_COMMON_EXPORT QJsonObject toJson(const LaserDesignation &element);
template<> TAB_COMMON_EXPORT LaserDesignation fromJson(const QJsonValue &val, type<LaserDesignation>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< LaserDesignation > &element);
template<> TAB_COMMON_EXPORT std::vector<LaserDesignation> fromJson(const QJsonValue &value, type< std::vector< LaserDesignation > >);


// MineTriggered
TAB_COMMON_EXPORT QJsonObject toJson(const MineTriggered &element);
template<> TAB_COMMON_EXPORT MineTriggered fromJson(const QJsonValue &val, type<MineTriggered>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< MineTriggered > &element);
template<> TAB_COMMON_EXPORT std::vector<MineTriggered> fromJson(const QJsonValue &value, type< std::vector< MineTriggered > >);


// MinelayerThrowerData
TAB_COMMON_EXPORT QJsonObject toJson(const MinelayerThrowerData &element);
template<> TAB_COMMON_EXPORT MinelayerThrowerData fromJson(const QJsonValue &val, type<MinelayerThrowerData>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< MinelayerThrowerData > &element);
template<> TAB_COMMON_EXPORT std::vector<MinelayerThrowerData> fromJson(const QJsonValue &value, type< std::vector< MinelayerThrowerData > >);


// MinelayerTrailerData
TAB_COMMON_EXPORT QJsonObject toJson(const MinelayerTrailerData &element);
template<> TAB_COMMON_EXPORT MinelayerTrailerData fromJson(const QJsonValue &val, type<MinelayerTrailerData>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< MinelayerTrailerData > &element);
template<> TAB_COMMON_EXPORT std::vector<MinelayerTrailerData> fromJson(const QJsonValue &value, type< std::vector< MinelayerTrailerData > >);


// MinelayerTrailerPosition
TAB_COMMON_EXPORT QJsonObject toJson(const MinelayerTrailerPosition &element);
template<> TAB_COMMON_EXPORT MinelayerTrailerPosition fromJson(const QJsonValue &val, type<MinelayerTrailerPosition>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< MinelayerTrailerPosition > &element);
template<> TAB_COMMON_EXPORT std::vector<MinelayerTrailerPosition> fromJson(const QJsonValue &value, type< std::vector< MinelayerTrailerPosition > >);


// OcData
TAB_COMMON_EXPORT QJsonObject toJson(const OcData &element);
template<> TAB_COMMON_EXPORT OcData fromJson(const QJsonValue &val, type<OcData>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< OcData > &element);
template<> TAB_COMMON_EXPORT std::vector<OcData> fromJson(const QJsonValue &value, type< std::vector< OcData > >);


// OperatorAction
TAB_COMMON_EXPORT QJsonObject toJson(const OperatorAction &element);
template<> TAB_COMMON_EXPORT OperatorAction fromJson(const QJsonValue &val, type<OperatorAction>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< OperatorAction > &element);
template<> TAB_COMMON_EXPORT std::vector<OperatorAction> fromJson(const QJsonValue &value, type< std::vector< OperatorAction > >);


// ParticipantConfigurationReport
TAB_COMMON_EXPORT QJsonObject toJson(const ParticipantConfigurationReport &element);
template<> TAB_COMMON_EXPORT ParticipantConfigurationReport fromJson(const QJsonValue &val, type<ParticipantConfigurationReport>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< ParticipantConfigurationReport > &element);
template<> TAB_COMMON_EXPORT std::vector<ParticipantConfigurationReport> fromJson(const QJsonValue &value, type< std::vector< ParticipantConfigurationReport > >);


// ParticipantModeReport
TAB_COMMON_EXPORT QJsonObject toJson(const ParticipantModeReport &element);
template<> TAB_COMMON_EXPORT ParticipantModeReport fromJson(const QJsonValue &val, type<ParticipantModeReport>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< ParticipantModeReport > &element);
template<> TAB_COMMON_EXPORT std::vector<ParticipantModeReport> fromJson(const QJsonValue &value, type< std::vector< ParticipantModeReport > >);


// ParticipantSanitaryMaterialStockReport
TAB_COMMON_EXPORT QJsonObject toJson(const ParticipantSanitaryMaterialStockReport &element);
template<> TAB_COMMON_EXPORT ParticipantSanitaryMaterialStockReport fromJson(const QJsonValue &val, type<ParticipantSanitaryMaterialStockReport>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< ParticipantSanitaryMaterialStockReport > &element);
template<> TAB_COMMON_EXPORT std::vector<ParticipantSanitaryMaterialStockReport> fromJson(const QJsonValue &value, type< std::vector< ParticipantSanitaryMaterialStockReport > >);


// ParticipantSanitation
TAB_COMMON_EXPORT QJsonObject toJson(const ParticipantSanitation &element);
template<> TAB_COMMON_EXPORT ParticipantSanitation fromJson(const QJsonValue &val, type<ParticipantSanitation>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< ParticipantSanitation > &element);
template<> TAB_COMMON_EXPORT std::vector<ParticipantSanitation> fromJson(const QJsonValue &value, type< std::vector< ParticipantSanitation > >);


// ParticipantSanitationRepair
TAB_COMMON_EXPORT QJsonObject toJson(const ParticipantSanitationRepair &element);
template<> TAB_COMMON_EXPORT ParticipantSanitationRepair fromJson(const QJsonValue &val, type<ParticipantSanitationRepair>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< ParticipantSanitationRepair > &element);
template<> TAB_COMMON_EXPORT std::vector<ParticipantSanitationRepair> fromJson(const QJsonValue &value, type< std::vector< ParticipantSanitationRepair > >);


// ParticipantSwVersions
TAB_COMMON_EXPORT QJsonObject toJson(const ParticipantSwVersions &element);
template<> TAB_COMMON_EXPORT ParticipantSwVersions fromJson(const QJsonValue &val, type<ParticipantSwVersions>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< ParticipantSwVersions > &element);
template<> TAB_COMMON_EXPORT std::vector<ParticipantSwVersions> fromJson(const QJsonValue &value, type< std::vector< ParticipantSwVersions > >);


// RestoreRadioReadiness
TAB_COMMON_EXPORT QJsonObject toJson(const RestoreRadioReadiness &element);
template<> TAB_COMMON_EXPORT RestoreRadioReadiness fromJson(const QJsonValue &val, type<RestoreRadioReadiness>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< RestoreRadioReadiness > &element);
template<> TAB_COMMON_EXPORT std::vector<RestoreRadioReadiness> fromJson(const QJsonValue &value, type< std::vector< RestoreRadioReadiness > >);


// ServiceControl
TAB_COMMON_EXPORT QJsonObject toJson(const ServiceControl &element);
template<> TAB_COMMON_EXPORT ServiceControl fromJson(const QJsonValue &val, type<ServiceControl>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< ServiceControl > &element);
template<> TAB_COMMON_EXPORT std::vector<ServiceControl> fromJson(const QJsonValue &value, type< std::vector< ServiceControl > >);


// SpecialSensorData
TAB_COMMON_EXPORT QJsonObject toJson(const SpecialSensorData &element);
template<> TAB_COMMON_EXPORT SpecialSensorData fromJson(const QJsonValue &val, type<SpecialSensorData>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< SpecialSensorData > &element);
template<> TAB_COMMON_EXPORT std::vector<SpecialSensorData> fromJson(const QJsonValue &value, type< std::vector< SpecialSensorData > >);


// StateIed
TAB_COMMON_EXPORT QJsonObject toJson(const StateIed &element);
template<> TAB_COMMON_EXPORT StateIed fromJson(const QJsonValue &val, type<StateIed>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< StateIed > &element);
template<> TAB_COMMON_EXPORT std::vector<StateIed> fromJson(const QJsonValue &value, type< std::vector< StateIed > >);


// TabPosition
TAB_COMMON_EXPORT QJsonObject toJson(const TabPosition &element);
template<> TAB_COMMON_EXPORT TabPosition fromJson(const QJsonValue &val, type<TabPosition>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< TabPosition > &element);
template<> TAB_COMMON_EXPORT std::vector<TabPosition> fromJson(const QJsonValue &value, type< std::vector< TabPosition > >);


// TargetData
TAB_COMMON_EXPORT QJsonObject toJson(const TargetData &element);
template<> TAB_COMMON_EXPORT TargetData fromJson(const QJsonValue &val, type<TargetData>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< TargetData > &element);
template<> TAB_COMMON_EXPORT std::vector<TargetData> fromJson(const QJsonValue &value, type< std::vector< TargetData > >);


// TrajectoryAdler
TAB_COMMON_EXPORT QJsonObject toJson(const TrajectoryAdler &element);
template<> TAB_COMMON_EXPORT TrajectoryAdler fromJson(const QJsonValue &val, type<TrajectoryAdler>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< TrajectoryAdler > &element);
template<> TAB_COMMON_EXPORT std::vector<TrajectoryAdler> fromJson(const QJsonValue &value, type< std::vector< TrajectoryAdler > >);


// TrajectoryCalculationData
TAB_COMMON_EXPORT QJsonObject toJson(const TrajectoryCalculationData &element);
template<> TAB_COMMON_EXPORT TrajectoryCalculationData fromJson(const QJsonValue &val, type<TrajectoryCalculationData>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< TrajectoryCalculationData > &element);
template<> TAB_COMMON_EXPORT std::vector<TrajectoryCalculationData> fromJson(const QJsonValue &value, type< std::vector< TrajectoryCalculationData > >);


// UASMissionStatus
TAB_COMMON_EXPORT QJsonObject toJson(const UASMissionStatus &element);
template<> TAB_COMMON_EXPORT UASMissionStatus fromJson(const QJsonValue &val, type<UASMissionStatus>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< UASMissionStatus > &element);
template<> TAB_COMMON_EXPORT std::vector<UASMissionStatus> fromJson(const QJsonValue &value, type< std::vector< UASMissionStatus > >);


// UASRadioLinkConnectionState
TAB_COMMON_EXPORT QJsonObject toJson(const UASRadioLinkConnectionState &element);
template<> TAB_COMMON_EXPORT UASRadioLinkConnectionState fromJson(const QJsonValue &val, type<UASRadioLinkConnectionState>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< UASRadioLinkConnectionState > &element);
template<> TAB_COMMON_EXPORT std::vector<UASRadioLinkConnectionState> fromJson(const QJsonValue &value, type< std::vector< UASRadioLinkConnectionState > >);


// UASStatus
TAB_COMMON_EXPORT QJsonObject toJson(const UASStatus &element);
template<> TAB_COMMON_EXPORT UASStatus fromJson(const QJsonValue &val, type<UASStatus>);
TAB_COMMON_EXPORT QJsonValue toJson(const std::vector< UASStatus > &element);
template<> TAB_COMMON_EXPORT std::vector<UASStatus> fromJson(const QJsonValue &value, type< std::vector< UASStatus > >);




//
// extensions to support sequence of seqence of Non-POD :
//


} // namespace TrainingAreaBase