// copyright 2021-23 BAE Systems
// copyright 2023 Real-Time Innovations
// copyright 2023 Sparx Systems Pty Ltd
// copyright 2023 SimVentions
// copyright 2023 Open Text Inc.
// copyright 2021-23 Object Management Group Inc

// Version 1.0

#ifndef ORGOMGTDAIDATAMODELPLANEXECUTIONDEFVAR
#define ORGOMGTDAIDATAMODELPLANEXECUTIONDEFVAR
#include "TacticalPicture.idl"
#include "Utils.idl"
#include "EntityPayload.idl"
#include "Util.idl"

module org
{

  module omg
  {

    module tdai
    {

      module DataModel
      {

        // The Plan Execution package of the Data Model defines the generic concepts
        // necessary to recommend, execute and amend tactical plans. Domain and system
        // specific concepts are abstracted using the Descriptor extension mechanism.
        module PlanExecution
        {

          // Enumeration of specialisations options for union class Capability.
          enum CapabilityKind
          {
            // EngineeringCapability option for Capability
            ENGINEERING_CAPABILITY_KIND,
            // FireCapability option for Capability
            FIRE_CAPABILITY_KIND,
            // MobilityCapability option for Capability
            MOBILITY_CAPABILITY_KIND,
            // OperationalCapability option for Capability
            OPERATIONAL_CAPABILITY_KIND,
            // SurveillanceCapability option for Capability
            SURVEILLANCE_CAPABILITY_KIND,
            // TransmissionCapability option for Capability
            TRANSMISSION_CAPABILITY_KIND
          };

          // Enumeration of specialisations options for union class Derivation.
          enum DerivationKind
          {
            // DerivationCategory option for Derivation
            DERIVATION_CATEGORY_KIND,
            // DerivationProvenance option for Derivation
            DERIVATION_PROVENANCE_KIND
          };

          // Derivation conforming to the W3C PROV recommendation
          struct DerivationProvenance
          {
            // The entity pertaining to the derivation in the corresponding provenance resource,
            // conforming to the W3C PROV recommendation.
            org::omg::tex::DataPayload::Util::URI provenanceEntity;
            // The provenance resource conforming to the W3C PROV recommendation, containing the
            // provenance metadata for the derivation
            org::omg::tex::DataPayload::Util::URL provenanceResource;
          };

          // A vehicle primarily for traveling on land
          struct LandVehicle
          {
            // The land vehicle is legal for driving on the roads (in the territory applicable
            // to the current system context).
            boolean roadLegal;
            // Whether the land vehicle can be driven off-road. More granular off-road
            // capabilities are specified using the mobility capability specialization.
            boolean offRoadCapable;
            // The radius of the land vehicle's tightest turning circle.
            org::omg::tex::DataPayload::Util::Distance minTurningRadius;
          };

          // Equipment to be deployed in the maritime environment from surface or subsurface
          // vessels. Maritime equipment do not encompass an entire vessel. The inherited
          // owner-resource self-association relation from the parent Resource class applies
          // between the Vessel and MaritimeEquipment classes.
          struct MaritimeEquipment
          {
            // Where a resource denotes a set of items this attribute specifies how many there
            // are. A default of 1 is used for single items.
            short collectionSize;
          };

          // Enumeration of specialisations options for union class PlanExecutionConstituent.
          enum PlanExecutionConstituentKind
          {
            // Plan option for PlanExecutionConstituent
            PLAN_KIND,
            // ResourceTasking option for PlanExecutionConstituent
            RESOURCE_TASKING_KIND,
            // TaskObjective option for PlanExecutionConstituent
            TASK_OBJECTIVE_KIND
          };

          // Enumeration of specialisations options for union class ResourceProperties.
          enum ResourcePropertiesKind
          {
            // base option for ResourceProperties
            RESOURCE_PROPERTIES_BASE_KIND,
            // ElectronicEquipment option for ResourceProperties
            ELECTRONIC_EQUIPMENT_KIND,
            // MaritimeEquipment option for ResourceProperties
            MARITIME_EQUIPMENT_KIND,
            // Vehicle option for ResourceProperties
            VEHICLE_KIND
          };

          struct TargetCapability
          {
            // A category of target for which the resource has a Fire Capability
            org::omg::tdai::DataModel::TacticalPicture::ClassificationDescriptor classification;
            // The nominal likelihood that an engagement with the specified target will be
            // successful.
            org::omg::tdai::MetaModel::DataModel::Utils::Percentage successLikelihood;
          };

          // Enumeration of specialisations options for union class Vehicle.
          enum VehicleKind
          {
            // base option for Vehicle
            VEHICLE_BASE_KIND,
            // Aircraft option for Vehicle
            AIRCRAFT_KIND,
            // Amphibious option for Vehicle
            AMPHIBIOUS_KIND,
            // LandVehicle option for Vehicle
            LAND_VEHICLE_KIND,
            // Space option for Vehicle
            SPACE_KIND,
            // Vessel option for Vehicle
            VESSEL_KIND
          };

          // Enumeration of specialisations options for union class Vessel.
          enum VesselKind
          {
            // base option for Vessel
            VESSEL_BASE_KIND,
            // SubsurfaceVessel option for Vessel
            SUBSURFACE_VESSEL_KIND,
            // SurfaceVessel option for Vessel
            SURFACE_VESSEL_KIND
          };

          // An abstraction of the categories of ammunition
          struct AmmunitionCategory
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // An abstraction of the categories of ammunition caliber.
          struct CaliberCategory
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // An abstraction of the categories of capabilities
          struct CapabilityCategory
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // A datatype with a platform specific mapping to represent a reference to a
          // Capability. A reference is a unique identifier within the scope of the Plan
          // Execution component implementing this specification.
          typedef org::omg::tdai::MetaModel::DataModel::Utils::DataRef CapabilityRef;

          // A reference to a Plan Execution Constituent. A reference is a unique identifier
          // within the scope of the Plan Execution component implementing this specification.
          typedef org::omg::tdai::MetaModel::DataModel::Utils::DataRef ConstituentRef;

          // An abstraction of the categories of dependencies
          struct DependencyCategory
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // System specific description of the derivation of the associated data
          struct DerivationDescriptor
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // An abstraction of additional sub-categories of plan status; each sub-category
          // logically maps to a specific plan state
          struct ExtendedPlanStatus
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // An abstraction of the categories of intent.
          struct IntentDescriptor
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // An abstraction of the categories of task objectives.
          struct ObjectiveCategory
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          struct CurrentCapability
          {
            CapabilityRef capabilityId;
            // A quantitative description of the Capability
            org::omg::tdai::MetaModel::DataModel::Utils::Quantifier quantifier;
          };

          // An abstraction of the categories of orbits in space
          struct OrbitCategory
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // Representation of the state machine for plan constituents.
          enum PlanExecutionConstituentState
          {
            // The plan constituent has been created but is not yet being executed
            PLANNED,
            // The plan constituent has been started but terminated and has been resumed after
            // any pause.
            EXECUTING,
            // The plan constituent has been paused, but not yet resumed after being executed.
            PAUSED,
            // The plan constituent has been terminated after being executed.
            TERMINATED
          };

          // An abstraction of the categories of plans.
          struct PlanType
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // An abstraction of the categories of readiness
          struct ReadinessDescriptor
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // An abstraction of the categories of resources.
          struct ResourceCategory
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // A datatype with a platform specific mapping to represent a reference to a
          // Resource. A reference is a unique identifier within the scope of the Plan
          // Execution component implementing this specification.
          typedef org::omg::tdai::MetaModel::DataModel::Utils::DataRef ResourceRef;

          // An abstraction of the categories of specifications
          struct SpecificationDescriptor
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // An abstraction of the categories of tasking activity a resource can undertake.
          struct TaskingActivity
          {
            // Prefix for the schema from which the value is drawn
            string schemaPrefix;
            // Value from the schema denoted by the prefix
            string value;
          };

          // a simple union type, to represent an optional value
          union AircraftMaxOperatingAltitude switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::Distance value;
          };

          // a simple union type, to represent an optional value
          union AircraftStallSpeed switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::Speed value;
          };

          // a simple union type, to represent an optional value
          union AmphibiousMaxOperatingDepth switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::Distance value;
          };

          // a simple union type, to represent an optional value
          union AmphibiousMaxSeaState switch (boolean)
          {
            // the value when present
            case TRUE : short value;
          };

          // a simple union type, to represent an optional value
          union AmphibiousMinOperatingDepth switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::Distance value;
          };

          // A sequence type, to represent multiple values.
          typedef sequence<org::omg::tdai::MetaModel::DataModel::Utils::Quantifier> DependencyQuantifier;

          // a simple union type, to represent an optional value
          union EnduranceFuelLevel switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // a simple union type, to represent an optional value
          union EnduranceConsumptionRate switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // a simple union type, to represent an optional value
          union EnduranceScheduledRefueling switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::DateTime value;
          };

          // a simple union type, to represent an optional value
          union EndurancePropertiesFuelCapacity switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // A system specific categorical derivation
          struct DerivationCategory
          {
            DerivationDescriptor value;
          };

          // a simple union type, to represent an optional value
          union EndurancePropertiesConsumptionRate switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // a simple union type, to represent an optional value
          union EndurancePropertiesPeakConsumptionRate switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // a simple union type, to represent an optional value
          union EngineeringCapabilityOutputRate switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // A sequence type, to represent multiple values.
          typedef sequence<org::omg::tdai::DataModel::TacticalPicture::ClassificationDescriptor> EngineeringCapabilityTargetClassification;

          // a simple union type, to represent an optional value
          union FireCapabilityMaxFireRate switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // a simple union type, to represent an optional value
          union FireCapabilityEngagementZoneId switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::URI value;
          };

          // a simple union type, to represent an optional value
          union MobilityCapabilityMaxLoadVolume switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // a simple union type, to represent an optional value
          union MobilityCapabilityMaxPassengers switch (boolean)
          {
            // the value when present
            case TRUE : short value;
          };

          // a simple union type, to represent an optional value
          union MobilityCapabilityMaxLoadWeight switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // a simple union type, to represent an optional value
          union OperationalCapabilityOperatingAreaId switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::URI value;
          };

          // A sequence type, to represent multiple values.
          typedef sequence<string> PlanSubPlanId;

          // A sequence type, to represent multiple values.
          typedef sequence<string> PlanConstraintId;

          // A sequence type, to represent multiple values.
          typedef sequence<string> PlanObjectiveId;

          // a simple union type, to represent an optional value
          union PlanLocationId switch (boolean)
          {
            // the value when present
            case TRUE : string value;
          };

          // a simple union type, to represent an optional value
          union PlanExecutionConstituentTimeSpan switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::Period value;
          };

          // a simple union type, to represent an optional value
          union PlanExecutionConstituentProgress switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Percentage value;
          };

          // a simple union type, to represent an optional value
          union ResourceWeight switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // a simple union type, to represent an optional value
          union ResourceEntity switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::EntityPayload::EntityRef value;
          };

          // a simple union type, to represent an optional value
          union ResourceCurrentPlanId switch (boolean)
          {
            // the value when present
            case TRUE : string value;
          };

          // a simple union type, to represent an optional value
          union ResourceCurrentObjectiveId switch (boolean)
          {
            // the value when present
            case TRUE : string value;
          };

          // A sequence type, to represent multiple values.
          typedef sequence<string> ResourceCurrentTaskId;

          // a simple union type, to represent an optional value
          union ResourceTaskingObjectiveId switch (boolean)
          {
            // the value when present
            case TRUE : string value;
          };

          // a simple union type, to represent an optional value
          union SubsurfaceVesselMaxOperatingDepth switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::Distance value;
          };

          // a simple union type, to represent an optional value
          union SurfaceVesselMaxSeaState switch (boolean)
          {
            // the value when present
            case TRUE : short value;
          };

          // a simple union type, to represent an optional value
          union SurveillanceCapabilityReportingRate switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // A sequence type, to represent multiple values.
          typedef sequence<org::omg::tdai::DataModel::TacticalPicture::ClassificationDescriptor> SurveillanceCapabilityTargetClassification;

          // a simple union type, to represent an optional value
          union SurveillanceCapabilityCapacity switch (boolean)
          {
            // the value when present
            case TRUE : short value;
          };

          // a simple union type, to represent an optional value
          union SurveillanceCapabilityCoverageAreaId switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::URI value;
          };

          // a simple union type, to represent an optional value
          union TaskObjectiveEntityObject switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::EntityPayload::EntityRef value;
          };

          // a simple union type, to represent an optional value
          union TaskObjectivePriority switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Percentage value;
          };

          // A sequence type, to represent multiple values.
          typedef sequence<string> TaskObjectiveTaskingId;

          // a simple union type, to represent an optional value
          union TaskObjectiveOwningPlanId switch (boolean)
          {
            // the value when present
            case TRUE : string value;
          };

          // a simple union type, to represent an optional value
          union TransmissionCapabilityPower switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // a simple union type, to represent an optional value
          union TransmissionCapabilityDataRate switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // A sequence type, to represent multiple values.
          typedef sequence<org::omg::tdai::MetaModel::DataModel::Utils::Descriptor> TransmissionCapabilityProtocol;

          // A sequence type, to represent multiple values.
          typedef sequence<org::omg::tdai::MetaModel::DataModel::Utils::Descriptor> TransmissionCapabilityDataClassification;

          // a simple union type, to represent an optional value
          union TransmissionCapabilityCoverageAreaId switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::URI value;
          };

          // a simple union type, to represent an optional value
          union VehicleMaxSpeed switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::Speed value;
          };

          // a simple union type, to represent an optional value
          union VehicleCruisingSpeed switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::Speed value;
          };

          // a simple union type, to represent an optional value
          union VehicleTurnRate switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tdai::MetaModel::DataModel::Utils::Quantifier value;
          };

          // a simple union type, to represent an optional value
          union VesselMinOperatingDepth switch (boolean)
          {
            // the value when present
            case TRUE : org::omg::tex::DataPayload::Util::Distance value;
          };

          // A resource beyond the Earth's atmosphere
          struct Space
          {
            // The kind of orbit or trajectory that the space resource is on
            OrbitCategory orbit;
          };

          // Description of the ammunition associated with a fire capability. Here, ammunition
          // generalizes to include bombs, torpedoes, decoys and missiles.
          struct Ammunition
          {
            // An extensible categorization of the ammunition type 
            AmmunitionCategory category;
            // An extensible description of the ammunition caliber (i.e. size).
            CaliberCategory caliber;
            // An extensibility mechanism for system specific ammunition attributes.
            org::omg::tdai::MetaModel::DataModel::Utils::AdditionalData extendedData;
            string Id;
          };

          // Struct of base attributes defined for class Capability.
          struct CapabilityBase
          {
            // An extensible categorization of the kind of capability being described.
            CapabilityCategory category;
            // An extensibility mechanism for system specific capability attributes.
            org::omg::tdai::MetaModel::DataModel::Utils::AdditionalData extendedData;
            // The unique identifier for the instance.
#ifdef DDS_XTYPES
            @key CapabilityRef id;
#else
            CapabilityRef id;
#endif
          };

          // Union of the specialisations for class Derivation.
          // An abstract class for derivation metadata
          union Derivation switch (DerivationKind)
          {
            // DerivationCategory option for Derivation
            case DERIVATION_CATEGORY_KIND : DerivationCategory derivationCategory;
            // DerivationProvenance option for Derivation
            case DERIVATION_PROVENANCE_KIND : DerivationProvenance derivationProvenance;
          };

          // A sequence type, to represent multiple values.
          typedef sequence<TargetCapability> FireCapabilityTarget;

          // A resource operating underwater
          struct SubsurfaceVessel
          {
            // The operating limit of the subsurface vehicle with respect to depth in the water
            SubsurfaceVesselMaxOperatingDepth maxOperatingDepth;
          };

          // A resource operating on water.
          struct SurfaceVessel
          {
            // The maximum sea state in which the Surface Vessel can operate specified in terms
            // of the World Meteorological Organization (WMO) sea state code - range 0 .. 9.
            SurfaceVesselMaxSeaState maxSeaState;
          };

          // Struct of base attributes defined for class Vessel.
          struct VesselBase
          {
            // The vessel resource's operating limit with respect to shallow water
            VesselMinOperatingDepth minOperatingDepth;
          };

          // a simple union type, to represent an optional value
          union PlanPlanType switch (boolean)
          {
            // the value when present
            case TRUE : PlanType value;
          };

          // A sequence type, to represent multiple values.
          typedef sequence<SpecificationDescriptor> ElectronicEquipmentApi;

          // An airborne resource
          struct Aircraft
          {
            // The maximum altitude (barometric) at which the aircraft is able to operate
            AircraftMaxOperatingAltitude maxOperatingAltitude;
            // The minimum speed for the aircraft resource to operate below which it risks a
            // stall.
            AircraftStallSpeed stallSpeed;
          };

          // A sequence type, to represent multiple values.
          typedef sequence<CurrentCapability> ResourceCurrentCapability;

          // A sequence type, to represent multiple values.
          typedef sequence<ResourceRef> OperationalCapabilitySupportingResourceId;

          // A sequence type, to represent multiple values.
          typedef sequence<ResourceRef> PlanRequiredResourceId;

          // A sequence type, to represent multiple values.
          typedef sequence<ResourceRef> ResourceResourceId;

          // a simple union type, to represent an optional value
          union ResourceOwnerId switch (boolean)
          {
            // the value when present
            case TRUE : ResourceRef value;
          };

          // A resource whose primary capabilities relate to its electronic components.
          struct ElectronicEquipment
          {
            // The set of interfaces standards that the equipment supports through which
            // integrated functionality can be delivered to Plan Execution.
            ElectronicEquipmentApi api;
          };

          // A capability to build, maintain, breach or demolish structures or infrastructure
          // in the operational environment
          struct EngineeringCapability
          {
            // The nominal rate at which the engineering capability can be delivered.
            EngineeringCapabilityOutputRate outputRate;
            // The categories of object to which the Engineering Capability can be applied.
            EngineeringCapabilityTargetClassification targetClassification;
          };

          struct Amphibious
          {
            // The operating limit of the amphibious vehicle with respect to depth in the water
            AmphibiousMaxOperatingDepth maxOperatingDepth;
            // The  World Meteorological Organization (WMO) sea state code - range 0 .. 9.
            AmphibiousMaxSeaState maxSeaState;
            // The amphibious resource's operating limit with respect to shallow water
            AmphibiousMinOperatingDepth minOperatingDepth;
            // The radius of the amphibious vehicle's tightest turning circle.
            org::omg::tex::DataPayload::Util::Distance minTurningRadius;
            // Whether the amphibious vehicle can be driven off-road. More granular off-road
            // capabilities are specified using the mobility capability specialization.
            boolean offRoadCapable;
            // The amphibious vehicle is legal for driving on the roads (in the territory
            // applicable to the current system context).
            boolean roadLegal;
          };

          struct ResourceMetaData
          {
            // The unit used to defined the Resources distance properties
            org::omg::tex::DataPayload::Util::DistanceUnit distanceUnit;
            // The unit used to define the Resource's speed properties
            org::omg::tex::DataPayload::Util::SpeedUnit speedUnit;
            // A description of the means by which the data for the Resource Property's
            // attributes were derived. This includes sensing, communication routes and human
            // input.
            Derivation derivation;
            ResourceRef Id;
          };

          // This class encapsulates the static, persistent endurance properties of a
          // resource.
          struct EnduranceProperties
          {
            // The maximum quantity of fuel that can be stored
            EndurancePropertiesFuelCapacity fuelCapacity;
            // The nominal or mean (as defined by the descriptor) rate at which the fuel is
            // consumed.
            EndurancePropertiesConsumptionRate consumptionRate;
            // The peak rate of fuel consumption
            EndurancePropertiesPeakConsumptionRate peakConsumptionRate;
            // Additional static information related to the Resource's Endurance
            org::omg::tdai::MetaModel::DataModel::Utils::AdditionalData extendedData;
          };

          // Operational capability describes the overall capabilities of a resource
          // comprising its associated personnel and equipment. It accounts for training,
          // readiness and equipment status.
          struct OperationalCapability
          {
            // The organizational level at which the operational capability is intended to be
            // performed
            org::omg::tdai::MetaModel::DataModel::Utils::Descriptor level;
            // The area to which the operational capability applies
            OperationalCapabilityOperatingAreaId operatingAreaId;
            // The Resources that support the Operational Capability of the composing Resource
            OperationalCapabilitySupportingResourceId supportingResourceId;
          };

          // An ability to transport objects and personnel.
          struct MobilityCapability
          {
            // The maximum load by volume (including passengers) that the Mobility Capability
            // can transport.
            MobilityCapabilityMaxLoadVolume maxLoadVolume;
            // The maximum number of passengers that can be transported
            MobilityCapabilityMaxPassengers maxPassengers;
            // The maximum load by weight (including passengers) that the Mobility Capability
            // can transport.
            MobilityCapabilityMaxLoadWeight maxLoadWeight;
          };

          // This class represents a dependent linkage between two resources or of a resource
          // on a particular capability.
          struct Dependency
          {
            // This is an extensible categorization of the type of dependency.
            DependencyCategory category;
            // The Resource satisfying the dependency
            ResourceRef dependentResourceId;
            // The Capability satisfying the dependency
            CapabilityRef dependentCapabilityId;
            // A quantitative description of the dependency
            DependencyQuantifier quantifier;
          };

          // An ability to apply physical effect towards an adversary.
          struct FireCapability
          {
            FireCapabilityMaxFireRate maxFireRate;
            // The Shaped Entity (or collection thereof) representing the spatial extent of the
            // Fire Capability. This includes any applicable minimum and maximum ranges as well
            // as blind arcs.
            FireCapabilityEngagementZoneId engagementZoneId;
            // The applicable categories of target for the Fire Capability
            FireCapabilityTarget target;
          };

          // Resource Tasking is a Resource's contribution to a Task Objective
          struct ResourceTasking
          {
            // An extensible categorization of the activity that the resource has been tasked to
            // undertake.
            TaskingActivity activity;
            // The Resource that is undertaking the Task
            ResourceRef resourceId;
            // The Resource's Capability that is required for the Task
            CapabilityRef capabilityMeansId;
            // The intended objective to which the tasking of a Resource contributes
            ResourceTaskingObjectiveId objectiveId;
          };

          // A sequence type, to represent multiple values.
          typedef sequence<Dependency> ResourceDependency;

          // This class encapsulates the dynamic endurance properties of a resource.
          struct Endurance
          {
            // The current quantity of fuel available
            EnduranceFuelLevel fuelLevel;
            // The current rate at which the fuel is consumed.
            EnduranceConsumptionRate consumptionRate;
            // Additional dynamic information related to the Resource's Endurance
            org::omg::tdai::MetaModel::DataModel::Utils::AdditionalData extendedData;
            // The time at which more fuel is scheduled to be available
            EnduranceScheduledRefueling scheduledRefueling;
            // The time for which the attributes of the Endurance class are valid.
            org::omg::tex::DataPayload::Util::DateTime timeOfValidity;
            // A description of the means by which the data for the Resource's Endurance
            // attributes were derived. This includes sensing, communication routes and human
            // input.
            Derivation derivation;
          };

          // Union of the variant attributes for the specialisations for class Vessel.
          // A waterborne resource
          union VesselVariants switch (VesselKind)
          {
            // SubsurfaceVessel option for Vessel
            case SUBSURFACE_VESSEL_KIND : SubsurfaceVessel subsurfaceVessel;
            // SurfaceVessel option for Vessel
            case SURFACE_VESSEL_KIND : SurfaceVessel surfaceVessel;
          };

          // Struct of base attributes defined for class PlanExecutionConstituent.
          struct PlanExecutionConstituentBase
          {
            // The unique identifier for the instance
#ifdef DDS_XTYPES
            @key ConstituentRef id;
#else
            ConstituentRef id;
#endif
            // The state of the plan constituent according to the PlanExecutionConstituent state
            // machine
            PlanExecutionConstituentState state;
            // The extensible detailed categorization of the state of the plan execution
            // constituent.
            ExtendedPlanStatus extendedStatus;
            // The time during which the plan execution constituent is expected to be executed.
            PlanExecutionConstituentTimeSpan timeSpan;
            // The originator of the PlanExecutionConstituent. This is the component that
            // instigated the creation of the instance.
            org::omg::tex::DataPayload::Util::URI originator;
            // The proportion of the plan execution constituent's objectives that have been
            // achieved.
            PlanExecutionConstituentProgress progress;
          };

          // A capability to sense or observe objects in the operational environment.
          struct SurveillanceCapability
          {
            SurveillanceCapabilityReportingRate reportingRate;
            // A qualitative description of the band in which the Surveillance Capability
            // operates
            org::omg::tdai::MetaModel::DataModel::Utils::Descriptor operatingBand;
            // The categories of object which the Surveillance Capability can detect
            SurveillanceCapabilityTargetClassification targetClassification;
            // The number of objects that the Surveillance Capability can continuously monitor.
            SurveillanceCapabilityCapacity capacity;
            // The Shaped Entity (or collection thereof) representing the Capability's
            // surveillance coverage.
            SurveillanceCapabilityCoverageAreaId coverageAreaId;
          };

          // a simple union type, to represent an optional value
          union ResourceEndurance switch (boolean)
          {
            // the value when present
            case TRUE : Endurance value;
          };

          // A capability for the electronic transmission of data (including voice and video).
          struct TransmissionCapability
          {
            // The nominal output 
            TransmissionCapabilityPower power;
            // The rate at which the Transmission Capability can transmit data
            TransmissionCapabilityDataRate dataRate;
            // A qualitative description of the band in which the Transmission Capability
            // operates
            org::omg::tdai::MetaModel::DataModel::Utils::Descriptor operatingBand;
            // The transmission protocols supported by the capability.
            TransmissionCapabilityProtocol protocol;
            // The classification of information supported by the capability
            TransmissionCapabilityDataClassification dataClassification;
            TransmissionCapabilityCoverageAreaId coverageAreaId;
          };

          // A Task Objective represents the discrete intent with respect to a particular
          // Entity from the tactical picture within the context of an overall Plan
          struct TaskObjective
          {
            // The Entity from the tactical picture to which the intent of the Task Objective is
            // directed.
            TaskObjectiveEntityObject entityObject;
            // An extensible categorization of the kind of tasking objective set.
            ObjectiveCategory category;
            // Extensible, additional system and/or domain specific description of the tasking
            // objective
            org::omg::tdai::MetaModel::DataModel::Utils::Detail detail;
            // Extensible categorization of the kind of effect intended with respect to the
            // object of the tasking
            IntentDescriptor intent;
            // Optional prioritization of task objectives. HIgher precentages reflect higher
            // priorities. The values for all objectives for a plan are not required to sum to
            // 100%.
            TaskObjectivePriority priority;
            // The tasks to be undertaken by Resources to achieve the objective
            TaskObjectiveTaskingId taskingId;
            // The plan of which the Task Objective is a component part
            TaskObjectiveOwningPlanId owningPlanId;
          };

          // Struct of base attributes defined for class Vehicle.
          struct VehicleBase
          {
            // The maximum speed that at which the vehicle can move
            VehicleMaxSpeed maxSpeed;
            // The optimum speed, for planning purposes, at which the vehicle transits between
            // locations.
            VehicleCruisingSpeed cruisingSpeed;
            // The rate at which the vehicle can maneuver to change its heading within the 
            // horizontal plane (for planning purposes).
            VehicleTurnRate turnRate;
            // The static properties of the Vehicle's Endurance
            EnduranceProperties endurance;
          };

          struct Vessel
          {
            // base option for Vessel
            VesselBase vesselBase;
            // variant options for Vessel
            VesselVariants vesselVariants;
          };

          // This is the DDS Topic type for invoking and implementing the PlanDataSink method on the PlanDataSink interface.
          // To invoke the operation publish a DDS Sample of this type; to implement it subscribe for samples.
          // 
          // Operation to obtain the information relating to the plan constituent reference
          // This interface contains operations that give a Tactical Decision Aid access to
          // information about the execution of plan constituents. A Tactical Decision Aid can
          // add and remove listeners as well as reading the information about individual plan
          // constituents or all or a filtered subset of plan constituents.
          // The interfaces to allow Tactical Decision Aids to receive Plan Information
          // A Plan represents an aggregated set of objectives and the resources and tasking
          // to achieve them.
          struct Plan
          {
            // The extensible categorization of the type of plan
            PlanPlanType planType;
            // The Resources that are needed to undertake the Plan
            PlanRequiredResourceId requiredResourceId;
            // The plan owning the component sub-plans
            // The component Plans of which the owning Plan is comprised.
            PlanSubPlanId subPlanId;
            // Entities that represent constraints to the plan
            PlanConstraintId constraintId;
            // The tasking objectives of the Plan
            PlanObjectiveId objectiveId;
            // An entity that represents the geographic properties of the Plan
            PlanLocationId locationId;
            // The plan owning the component sub-plans
            // The component Plans of which the owning Plan is comprised.
            string owningPlanId;
          };
#ifndef DDS_XTYPES
#pragma keylist Plan
#endif

          // Union of the variant attributes for the specialisations for class Vehicle.
          // A resource with its own movement capabilities
          union VehicleVariants switch (VehicleKind)
          {
            // Aircraft option for Vehicle
            case AIRCRAFT_KIND : Aircraft aircraft;
            // Amphibious option for Vehicle
            case AMPHIBIOUS_KIND : Amphibious amphibious;
            // LandVehicle option for Vehicle
            case LAND_VEHICLE_KIND : LandVehicle landVehicle;
            // Space option for Vehicle
            case SPACE_KIND : Space space;
            // Vessel option for Vehicle
            case VESSEL_KIND : Vessel vessel;
          };

          // Union of the variant attributes for the specialisations for class PlanExecutionConstituent.
          // The plan to which to apply the filter
          // This operation is the client's implementation of a filtering query for plan
          // constituents
          // This is an interface through which a client can define Queries on plan
          // constituents so as to filter the information returned. Classes implementing the
          // interface provide means to set the query parameters (such as a constructor).
          // An abstract class for constituent elements of tactical plan execution
          union PlanExecutionConstituentVariants switch (PlanExecutionConstituentKind)
          {
            // Plan option for PlanExecutionConstituent
            case PLAN_KIND : Plan plan;
            // ResourceTasking option for PlanExecutionConstituent
            case RESOURCE_TASKING_KIND : ResourceTasking resourceTasking;
            // TaskObjective option for PlanExecutionConstituent
            case TASK_OBJECTIVE_KIND : TaskObjective taskObjective;
          };

          struct Vehicle
          {
            // base option for Vehicle
            VehicleBase vehicleBase;
            // variant options for Vehicle
            VehicleVariants vehicleVariants;
          };

          // Union of the variant attributes for the specialisations for class Capability.
          // A Capability is an abstraction of a Resource's fundamental properties with
          // respect to its ability to undertake tasks
          union CapabilityVariants switch (CapabilityKind)
          {
            // EngineeringCapability option for Capability
            case ENGINEERING_CAPABILITY_KIND : EngineeringCapability engineeringCapability;
            // FireCapability option for Capability
            case FIRE_CAPABILITY_KIND : FireCapability fireCapability;
            // MobilityCapability option for Capability
            case MOBILITY_CAPABILITY_KIND : MobilityCapability mobilityCapability;
            // OperationalCapability option for Capability
            case OPERATIONAL_CAPABILITY_KIND : OperationalCapability operationalCapability;
            // SurveillanceCapability option for Capability
            case SURVEILLANCE_CAPABILITY_KIND : SurveillanceCapability surveillanceCapability;
            // TransmissionCapability option for Capability
            case TRANSMISSION_CAPABILITY_KIND : TransmissionCapability transmissionCapability;
          };

          struct PlanExecutionConstituent
          {
            // base option for PlanExecutionConstituent
            PlanExecutionConstituentBase planExecutionConstituentBase;
            // variant options for PlanExecutionConstituent
            PlanExecutionConstituentVariants planExecutionConstituentVariants;
          };
#ifndef DDS_XTYPES
#pragma keylist PlanExecutionConstituent planExecutionConstituentBase.id
#endif

          struct Capability
          {
            // base option for Capability
            CapabilityBase capabilityBase;
            // variant options for Capability
            CapabilityVariants capabilityVariants;
          };

          // This is the DDS Topic type for invoking and implementing the ResourceDataSink method on the ResourceDataSink interface.
          // To invoke the operation publish a DDS Sample of this type; to implement it subscribe for samples.
          // 
          // Operation to obtain the information relating to the Resource reference
          // This interface contains operations that give a Tactical Decision Aid access to
          // information about resources that can execute plans. A Tactical Decision Aid can
          // add and remove listeners as well as reading the information about individual
          // resources or all or a filtered subset of resources.
          // The interfaces to allow Tactical Decision Aids to receive Resource Information
          // A Resource is an abstraction of a physical entity that can be independently
          // tasked to achieve an objective.
          struct Resource
          {
            // The unique identifier for the instance
#ifdef DDS_XTYPES
            @key ResourceRef id;
#else
            ResourceRef id;
#endif
            // The current weight of the Resource
            ResourceWeight weight;
            // A reference to the entity representing the resource in the tactical picture
            ResourceEntity entity;
            // Additional dynamic information related to the Resource
            org::omg::tdai::MetaModel::DataModel::Utils::AdditionalData extendedData;
            // The extensible categorization of the readiness of resource (the extent to which
            // resource is ready and available to be tasked to employ its capabilities).
            ReadinessDescriptor readiness;
            // The time for which the attributes of the Resource class are valid.
            org::omg::tex::DataPayload::Util::DateTime timeOfValidity;
            // A description of the means by which the data for the Resource's attributes were
            // derived. This includes sensing, communication routes and human input.
            Derivation derivation;
            // The static properties for this resource
            ResourceRef propertiesId;
            // The Plan to which the Resource is currently working
            ResourceCurrentPlanId currentPlanId;
            // The Resource that aggregates, commands and controls multiple constituents
            // Resources
            // The Resources that are constituents of a higher-order aggregate Resource
            ResourceResourceId resourceId;
            // The objective that the Resource is currently working on
            ResourceCurrentObjectiveId currentObjectiveId;
            ResourceCurrentCapability currentCapability;
            // The task that the Resource is currently undertaking
            ResourceCurrentTaskId currentTaskId;
            // External Capabilities and Resources on which this Resource is dependent
            ResourceDependency dependency;
            // Information describing the endurance of the Resource
            ResourceEndurance endurance;
            // The Resource that aggregates, commands and controls multiple constituents
            // Resources
            // The Resources that are constituents of a higher-order aggregate Resource
            ResourceOwnerId ownerId;
          };
#ifndef DDS_XTYPES
#pragma keylist Resource id
#endif

          // Union of the variant attributes for the specialisations for class ResourceProperties.
          // The static, persistent properties of the resource that are not expected to change
          // as a plan is proposed and executed. Properties are specified in this data model
          // that are expected to be particular pertinent to the planning of operational
          // utilization of resources. For instance those that provide constraints on movement
          // and demand conditions on the operating environment.
          union ResourcePropertiesVariants switch (ResourcePropertiesKind)
          {
            // ElectronicEquipment option for ResourceProperties
            case ELECTRONIC_EQUIPMENT_KIND : ElectronicEquipment electronicEquipment;
            // MaritimeEquipment option for ResourceProperties
            case MARITIME_EQUIPMENT_KIND : MaritimeEquipment maritimeEquipment;
            // Vehicle option for ResourceProperties
            case VEHICLE_KIND : Vehicle vehicle;
          };

          // A sequence type, to represent multiple values.
          typedef sequence<Capability> ResourcePropertiesCapability;

          // Struct of base attributes defined for class ResourceProperties.
          struct ResourcePropertiesBase
          {
            // The extensible categorization of the type of resource
            ResourceCategory category;
            // Additional static information related to the Resource
            org::omg::tdai::MetaModel::DataModel::Utils::AdditionalData extendedData;
            // The unique identifier for the instance
#ifdef DDS_XTYPES
            @key ResourceRef id;
#else
            ResourceRef id;
#endif
            ResourcePropertiesCapability capability;
          };

          struct ResourceProperties
          {
            // base option for ResourceProperties
            ResourcePropertiesBase resourcePropertiesBase;
            // variant options for ResourceProperties
            ResourcePropertiesVariants resourcePropertiesVariants;
          };

        };
      };
    };
  };
};
#endif