rounac-uci 0.0.3

#![doc = r#"Module with schema-level elements."#]

use serde::{Deserialize, Serialize};
use std::convert::{AsRef, AsMut};
use std::convert::{From, Into};
use std::ops::{Deref, DerefMut};

#[doc = r#"This message provides the results of an access assessment.  An access assessment is a temporal analysis of possibilities for employment of capabilities of Objects against/to Subjects.  The results can be thought of as being organized in a table with Subjects as columns and Objects as rows.  For a given Subject-Object cell/pair in the table there are potentially many temporal and other assessment parameters given per Object level of effort per Object capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AccessAssessment(
	pub crate::v2_5::types::AccessAssessmentMt,
);
impl Deref for AccessAssessment {
	type Target = crate::v2_5::types::AccessAssessmentMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AccessAssessment {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AccessAssessmentMt> for AccessAssessment {
	fn as_ref(&self) -> &crate::v2_5::types::AccessAssessmentMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AccessAssessmentMt> for AccessAssessment {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AccessAssessmentMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AccessAssessmentMt> for AccessAssessment {
	fn from(p: crate::v2_5::types::AccessAssessmentMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AccessAssessmentMt> for AccessAssessment {
	fn into(self) -> crate::v2_5::types::AccessAssessmentMt {
		self.0
	}
}


#[doc = r#"This message is a request to generate an access assessment.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AccessAssessmentRequest(
	pub crate::v2_5::types::AccessAssessmentRequestMt,
);
impl Deref for AccessAssessmentRequest {
	type Target = crate::v2_5::types::AccessAssessmentRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AccessAssessmentRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AccessAssessmentRequestMt> for AccessAssessmentRequest {
	fn as_ref(&self) -> &crate::v2_5::types::AccessAssessmentRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AccessAssessmentRequestMt> for AccessAssessmentRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AccessAssessmentRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AccessAssessmentRequestMt> for AccessAssessmentRequest {
	fn from(p: crate::v2_5::types::AccessAssessmentRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AccessAssessmentRequestMt> for AccessAssessmentRequest {
	fn into(self) -> crate::v2_5::types::AccessAssessmentRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to the request for an access assessment.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AccessAssessmentRequestStatus(
	pub crate::v2_5::types::AccessAssessmentRequestStatusMt,
);
impl Deref for AccessAssessmentRequestStatus {
	type Target = crate::v2_5::types::AccessAssessmentRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AccessAssessmentRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AccessAssessmentRequestStatusMt> for AccessAssessmentRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AccessAssessmentRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AccessAssessmentRequestStatusMt> for AccessAssessmentRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AccessAssessmentRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AccessAssessmentRequestStatusMt> for AccessAssessmentRequestStatus {
	fn from(p: crate::v2_5::types::AccessAssessmentRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AccessAssessmentRequestStatusMt> for AccessAssessmentRequestStatus {
	fn into(self) -> crate::v2_5::types::AccessAssessmentRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies a C2 Requirement in the form/abstraction of an Action.  Other C2 Requirement forms include Effect, Task, [Capability]Command and  Response.  For example, a DEFEAT Effect could be planned/decomposed into a FIND Action, SAR Task, SAR_Command, Attack Action and Strike Task.  See the child EffectType element and its enumerates for the Effect taxonomy.  Actions can be planned (*Plan messages), directly commanded (ActionCommand* messages) and/or event-driven responses (Response* messages).UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Action(
	pub crate::v2_5::types::ActionMt,
);
impl Deref for Action {
	type Target = crate::v2_5::types::ActionMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Action {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionMt> for Action {
	fn as_ref(&self) -> &crate::v2_5::types::ActionMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionMt> for Action {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionMt> for Action {
	fn from(p: crate::v2_5::types::ActionMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionMt> for Action {
	fn into(self) -> crate::v2_5::types::ActionMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the Action Capability of a System.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionActivity(
	pub crate::v2_5::types::ActionActivityMt,
);
impl Deref for ActionActivity {
	type Target = crate::v2_5::types::ActionActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionActivityMt> for ActionActivity {
	fn as_ref(&self) -> &crate::v2_5::types::ActionActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionActivityMt> for ActionActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionActivityMt> for ActionActivity {
	fn from(p: crate::v2_5::types::ActionActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionActivityMt> for ActionActivity {
	fn into(self) -> crate::v2_5::types::ActionActivityMt {
		self.0
	}
}


#[doc = r#"This message is a request to cancel an Action which has been allocated and planned.  A planning input such as Effect, Action, Task and DMPI can't easily be canceled or removed from the System due to race conditions between their various users and publishers, inevitability of the associated activity, etc.  Additionally, the operator or service initiating the cancellation might be different than the one that manages RequirementSets and/or issues *PlanCommand, introducing additional race conditions.  In order to avoid race conditions, receive positive feedback on the success of the cancellation and allow canceled messages/objects to remain in the system for historical purposes, an explicit ActionCancelCommand is necessary.  An ActionCancelCommand shall result in the Action being canceled unless execution was already inevitable.  If the Action was inevitable and started executing but can be stopped (such as a long collection Action) it shall cancel as soon as possible.  ActionCancelCommand shall result in managers of RequirementSets to remove the associated Action, thereby removing the Action from the next planning cycle.  Services other than those that manage RequirementSets and execute activities aren't required to handle ActionCancelCommand.  ActionCancelCommand doesn't necessarily trigger a replan (there isn't a corresponding planning trigger), therefore a System could continue to navigate routes related to the canceled Action, even though the Action won't occur.  A subsequent replan could exclude the Action.  Status or feedback for this message is given through ActionCancelCommandStatus but the resulting status of the Action is given through ActionStatus.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionCancelCommand(
	pub crate::v2_5::types::ActionCancelCommandMt,
);
impl Deref for ActionCancelCommand {
	type Target = crate::v2_5::types::ActionCancelCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionCancelCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionCancelCommandMt> for ActionCancelCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ActionCancelCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionCancelCommandMt> for ActionCancelCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionCancelCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionCancelCommandMt> for ActionCancelCommand {
	fn from(p: crate::v2_5::types::ActionCancelCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionCancelCommandMt> for ActionCancelCommand {
	fn into(self) -> crate::v2_5::types::ActionCancelCommandMt {
		self.0
	}
}


#[doc = r#"This message is sent in response to an ActionCancelCommand and indicates if the Action was canceled and if not why it was not canceled.  The resulting status of the Action is reported in ActionStatus.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionCancelCommandStatus(
	pub crate::v2_5::types::ActionCancelCommandStatusMt,
);
impl Deref for ActionCancelCommandStatus {
	type Target = crate::v2_5::types::ActionCancelCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionCancelCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionCancelCommandStatusMt> for ActionCancelCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActionCancelCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionCancelCommandStatusMt> for ActionCancelCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionCancelCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionCancelCommandStatusMt> for ActionCancelCommandStatus {
	fn from(p: crate::v2_5::types::ActionCancelCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionCancelCommandStatusMt> for ActionCancelCommandStatus {
	fn into(self) -> crate::v2_5::types::ActionCancelCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message represents the Action category of UCI Capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionCapability(
	pub crate::v2_5::types::ActionCapabilityMt,
);
impl Deref for ActionCapability {
	type Target = crate::v2_5::types::ActionCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionCapabilityMt> for ActionCapability {
	fn as_ref(&self) -> &crate::v2_5::types::ActionCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionCapabilityMt> for ActionCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionCapabilityMt> for ActionCapability {
	fn from(p: crate::v2_5::types::ActionCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionCapabilityMt> for ActionCapability {
	fn into(self) -> crate::v2_5::types::ActionCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Action capabilities available to the system.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionCapabilityStatus(
	pub crate::v2_5::types::ActionCapabilityStatusMt,
);
impl Deref for ActionCapabilityStatus {
	type Target = crate::v2_5::types::ActionCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionCapabilityStatusMt> for ActionCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActionCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionCapabilityStatusMt> for ActionCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionCapabilityStatusMt> for ActionCapabilityStatus {
	fn from(p: crate::v2_5::types::ActionCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionCapabilityStatusMt> for ActionCapabilityStatus {
	fn into(self) -> crate::v2_5::types::ActionCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the Action form of the general UCI Capability Command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionCommand(
	pub crate::v2_5::types::ActionCommandMt,
);
impl Deref for ActionCommand {
	type Target = crate::v2_5::types::ActionCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionCommandMt> for ActionCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ActionCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionCommandMt> for ActionCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionCommandMt> for ActionCommand {
	fn from(p: crate::v2_5::types::ActionCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionCommandMt> for ActionCommand {
	fn into(self) -> crate::v2_5::types::ActionCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an ActionCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionCommandStatus(
	pub crate::v2_5::types::ActionCommandStatusMt,
);
impl Deref for ActionCommandStatus {
	type Target = crate::v2_5::types::ActionCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionCommandStatusMt> for ActionCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActionCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionCommandStatusMt> for ActionCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionCommandStatusMt> for ActionCommandStatus {
	fn from(p: crate::v2_5::types::ActionCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionCommandStatusMt> for ActionCommandStatus {
	fn into(self) -> crate::v2_5::types::ActionCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the state of approval for execution of a task. ApprovalPolicy allow an authority to define policies to approve or reject a Action as it enters execution. Approval may or may not be required. If approval is required, there can be multiple approvers. See Approval* messages for additional details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionExecutionApprovalStatus(
	pub crate::v2_5::types::ActionExecutionApprovalStatusMt,
);
impl Deref for ActionExecutionApprovalStatus {
	type Target = crate::v2_5::types::ActionExecutionApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionExecutionApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionExecutionApprovalStatusMt> for ActionExecutionApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActionExecutionApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionExecutionApprovalStatusMt> for ActionExecutionApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionExecutionApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionExecutionApprovalStatusMt> for ActionExecutionApprovalStatus {
	fn from(p: crate::v2_5::types::ActionExecutionApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionExecutionApprovalStatusMt> for ActionExecutionApprovalStatus {
	fn into(self) -> crate::v2_5::types::ActionExecutionApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies the Actions allocated to a System.  Allocation can be done manually by operators, by an allocation service or a combination.  This message decouples Action allocation from kinematic, action and other types of planning; Action allocations can be created, updated and approved independent of other *Plans.  It enables any type of *Plan to be a constraint on Action allocation.
An ActionPlan can be an input and/or output of planning processes.  For example the ActionPlan for the top System in a hierarchical System of System could be an input to an Action allocation service that the produces an ActionPlan per subordinate System with their subset of allocated Actions.
Additional details such as timing, dependencies, decomposition, etc. can be added during the Action allocation process and captured in the ActionPlan to supplement the information in the allocated Actions themselves.
An ActionPlan can be created discretely or as part of a MissionPlan that includes other *Plans.  An ActionPlan can only be activated and executed as part of a MissionPlan.  A MissionPlan can be used to plan the execution order of multiple ActionPlans and *Plans in general.  An ActionPlan can be subject to approval per Approval* messages.  Planning, approval, activation and execution state information for an ActionPlan are given in other ActionPlan* messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionPlan(
	pub crate::v2_5::types::ActionPlanMt,
);
impl Deref for ActionPlan {
	type Target = crate::v2_5::types::ActionPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionPlanMt> for ActionPlan {
	fn as_ref(&self) -> &crate::v2_5::types::ActionPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionPlanMt> for ActionPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionPlanMt> for ActionPlan {
	fn from(p: crate::v2_5::types::ActionPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionPlanMt> for ActionPlan {
	fn into(self) -> crate::v2_5::types::ActionPlanMt {
		self.0
	}
}


#[doc = r#"This message indicates status/state of approval for an ActionPlan.  Approval may or may not be required.  ApprovalPolicy aligned with the *Plans and states of planning allow a planning oversight authority to approve or reject plans as they're created or updated.  Approval may or may not be required.  If required, there may be many approvers.  See Approval* messages for additional details.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionPlanApprovalStatus(
	pub crate::v2_5::types::ActionPlanApprovalStatusMt,
);
impl Deref for ActionPlanApprovalStatus {
	type Target = crate::v2_5::types::ActionPlanApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionPlanApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionPlanApprovalStatusMt> for ActionPlanApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActionPlanApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionPlanApprovalStatusMt> for ActionPlanApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionPlanApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionPlanApprovalStatusMt> for ActionPlanApprovalStatus {
	fn from(p: crate::v2_5::types::ActionPlanApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionPlanApprovalStatusMt> for ActionPlanApprovalStatus {
	fn into(self) -> crate::v2_5::types::ActionPlanApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message invokes an ActionPlan planning process.  Each planning process is declared with a unique ID in the ControlStatus message; that ID is used in this message to invoke the process.  This message includes many inputs to the planning process but many others may come from a variety of other messages.  A few examples of the many inputs include:
1. Options for constraining the planning function in a variety of ways using existing Plans of the same type or by other Plan types.  For example, an ActionPlan could be constrained by a previous RoutePlan, a previous RouteActivityPlan and/or a TaskPlan.
2. Environment overrides to selectively modify details of the current planning environment in the context of a single planning command. For example, a known threat Entity in the environment could be removed and an expected Entity could be added to the environment in the context of a single planning command in support of "what-if" planning.
3. "Weightings" that influence the decisions of operators or planning algorithms performing the planning.
4. Temporal and/or kinematic begin and end points.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionPlanCommand(
	pub crate::v2_5::types::ActionPlanCommandMt,
);
impl Deref for ActionPlanCommand {
	type Target = crate::v2_5::types::ActionPlanCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionPlanCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionPlanCommandMt> for ActionPlanCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ActionPlanCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionPlanCommandMt> for ActionPlanCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionPlanCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionPlanCommandMt> for ActionPlanCommand {
	fn from(p: crate::v2_5::types::ActionPlanCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionPlanCommandMt> for ActionPlanCommand {
	fn into(self) -> crate::v2_5::types::ActionPlanCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to create/update an ActionPlan, including the current state in a command and processing state machine; see the ActionPlanCommand message.  Creation/update of an ActionPlan  may occur autonomously, without an ActionPlanCommand in which case the current state of the plan could be given in the ActionPlanStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionPlanCommandStatus(
	pub crate::v2_5::types::ActionPlanCommandStatusMt,
);
impl Deref for ActionPlanCommandStatus {
	type Target = crate::v2_5::types::ActionPlanCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionPlanCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionPlanCommandStatusMt> for ActionPlanCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActionPlanCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionPlanCommandStatusMt> for ActionPlanCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionPlanCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionPlanCommandStatusMt> for ActionPlanCommandStatus {
	fn from(p: crate::v2_5::types::ActionPlanCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionPlanCommandStatusMt> for ActionPlanCommandStatus {
	fn into(self) -> crate::v2_5::types::ActionPlanCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the execution status for one or more ActionPlans.  Plan execution begins after successful autonomous plan activation or activation via ActionPlanActivation messages.  This message provides execution status regardless of how execution was initiated.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionPlanExecutionStatus(
	pub crate::v2_5::types::ActionPlanExecutionStatusMt,
);
impl Deref for ActionPlanExecutionStatus {
	type Target = crate::v2_5::types::ActionPlanExecutionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionPlanExecutionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionPlanExecutionStatusMt> for ActionPlanExecutionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActionPlanExecutionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionPlanExecutionStatusMt> for ActionPlanExecutionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionPlanExecutionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionPlanExecutionStatusMt> for ActionPlanExecutionStatus {
	fn from(p: crate::v2_5::types::ActionPlanExecutionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionPlanExecutionStatusMt> for ActionPlanExecutionStatus {
	fn into(self) -> crate::v2_5::types::ActionPlanExecutionStatusMt {
		self.0
	}
}


#[doc = r#"This message provides status for an ActionPlan.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionPlanStatus(
	pub crate::v2_5::types::ActionPlanStatusMt,
);
impl Deref for ActionPlanStatus {
	type Target = crate::v2_5::types::ActionPlanStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionPlanStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionPlanStatusMt> for ActionPlanStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActionPlanStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionPlanStatusMt> for ActionPlanStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionPlanStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionPlanStatusMt> for ActionPlanStatus {
	fn from(p: crate::v2_5::types::ActionPlanStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionPlanStatusMt> for ActionPlanStatus {
	fn into(self) -> crate::v2_5::types::ActionPlanStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the validation, including the current state in a validation state machine, and details of invalid items. Validation may occur periodically, or onesie twosie. See the ActionPlanValidationCommand message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionPlanValidation(
	pub crate::v2_5::types::ActionPlanValidationMt,
);
impl Deref for ActionPlanValidation {
	type Target = crate::v2_5::types::ActionPlanValidationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionPlanValidation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionPlanValidationMt> for ActionPlanValidation {
	fn as_ref(&self) -> &crate::v2_5::types::ActionPlanValidationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionPlanValidationMt> for ActionPlanValidation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionPlanValidationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionPlanValidationMt> for ActionPlanValidation {
	fn from(p: crate::v2_5::types::ActionPlanValidationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionPlanValidationMt> for ActionPlanValidation {
	fn into(self) -> crate::v2_5::types::ActionPlanValidationMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to validate/re-validate an existing ActionPlan.  An ActionPlan can become invalid due to changes in Action timing, weather, order of battle, kinematic movement constraints, operator manual edits and many, many other reasons.  The message allows an existing ActionPlan to be checked for validity given such changes.  The variables a given planning service, operator or system considers when validating a plan varies.  Different variables might be considered depending on the level of detail of the plan or stage in the overall planning process.  The scope and meaning of "valid" comes from context of the services, operator and systems creating the plan.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionPlanValidationCommand(
	pub crate::v2_5::types::ActionPlanValidationCommandMt,
);
impl Deref for ActionPlanValidationCommand {
	type Target = crate::v2_5::types::ActionPlanValidationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionPlanValidationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionPlanValidationCommandMt> for ActionPlanValidationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ActionPlanValidationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionPlanValidationCommandMt> for ActionPlanValidationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionPlanValidationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionPlanValidationCommandMt> for ActionPlanValidationCommand {
	fn from(p: crate::v2_5::types::ActionPlanValidationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionPlanValidationCommandMt> for ActionPlanValidationCommand {
	fn into(self) -> crate::v2_5::types::ActionPlanValidationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to validate an ActionPlan, including the current state in a command and processing state machine.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionPlanValidationCommandStatus(
	pub crate::v2_5::types::ActionPlanValidationCommandStatusMt,
);
impl Deref for ActionPlanValidationCommandStatus {
	type Target = crate::v2_5::types::ActionPlanValidationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionPlanValidationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionPlanValidationCommandStatusMt> for ActionPlanValidationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActionPlanValidationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionPlanValidationCommandStatusMt> for ActionPlanValidationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionPlanValidationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionPlanValidationCommandStatusMt> for ActionPlanValidationCommandStatus {
	fn from(p: crate::v2_5::types::ActionPlanValidationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionPlanValidationCommandStatusMt> for ActionPlanValidationCommandStatus {
	fn into(self) -> crate::v2_5::types::ActionPlanValidationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message defines planning status of a single Action.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionPlanningStatus(
	pub crate::v2_5::types::ActionPlanningStatusMt,
);
impl Deref for ActionPlanningStatus {
	type Target = crate::v2_5::types::ActionPlanningStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionPlanningStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionPlanningStatusMt> for ActionPlanningStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActionPlanningStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionPlanningStatusMt> for ActionPlanningStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionPlanningStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionPlanningStatusMt> for ActionPlanningStatus {
	fn from(p: crate::v2_5::types::ActionPlanningStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionPlanningStatusMt> for ActionPlanningStatus {
	fn into(self) -> crate::v2_5::types::ActionPlanningStatusMt {
		self.0
	}
}


#[doc = r#"Indicates the execution status for an Action.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActionStatus(
	pub crate::v2_5::types::ActionStatusMt,
);
impl Deref for ActionStatus {
	type Target = crate::v2_5::types::ActionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActionStatusMt> for ActionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActionStatusMt> for ActionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActionStatusMt> for ActionStatus {
	fn from(p: crate::v2_5::types::ActionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActionStatusMt> for ActionStatus {
	fn into(self) -> crate::v2_5::types::ActionStatusMt {
		self.0
	}
}


#[doc = r#"This message provides metrics on predicted performance details of an ActivityPlan. Metrics include time-related metrics of the ActivityPlan. This message is intended for use prior to execution of a plan; for actual results of the plan, systems should use those status and activity messages produced during execution to derive metrics.
The intent of the *Plan Metrics messages are to provide calculated metrics that are based on existing plan input data. This is to continue the current paradigm of how metrics were represented in existing/previous MissionPlan and other sub plans. There is a distinction between the *Plan Metrics and the Assessment message, in that Assessment gives much more specific data and can consider other supporting systems and their capabilities in the assessment.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActivityMetrics(
	pub crate::v2_5::types::ActivityMetricsMt,
);
impl Deref for ActivityMetrics {
	type Target = crate::v2_5::types::ActivityMetricsMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActivityMetrics {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActivityMetricsMt> for ActivityMetrics {
	fn as_ref(&self) -> &crate::v2_5::types::ActivityMetricsMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActivityMetricsMt> for ActivityMetrics {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActivityMetricsMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActivityMetricsMt> for ActivityMetrics {
	fn from(p: crate::v2_5::types::ActivityMetricsMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActivityMetricsMt> for ActivityMetrics {
	fn into(self) -> crate::v2_5::types::ActivityMetricsMt {
		self.0
	}
}


#[doc = r#"This message requests the generation of metrics for a specific ActivityPlan. For details on what metrics are provided, see ActivityMetrics.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActivityMetricsRequest(
	pub crate::v2_5::types::ActivityMetricsRequestMt,
);
impl Deref for ActivityMetricsRequest {
	type Target = crate::v2_5::types::ActivityMetricsRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActivityMetricsRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActivityMetricsRequestMt> for ActivityMetricsRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ActivityMetricsRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActivityMetricsRequestMt> for ActivityMetricsRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActivityMetricsRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActivityMetricsRequestMt> for ActivityMetricsRequest {
	fn from(p: crate::v2_5::types::ActivityMetricsRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActivityMetricsRequestMt> for ActivityMetricsRequest {
	fn into(self) -> crate::v2_5::types::ActivityMetricsRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status of an ActivityMetricsRequest received by the applicable C2 system. In the event that metric reporting was incomplete, this message should provide details on why the process was unsuccessful.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActivityMetricsRequestStatus(
	pub crate::v2_5::types::ActivityMetricsRequestStatusMt,
);
impl Deref for ActivityMetricsRequestStatus {
	type Target = crate::v2_5::types::ActivityMetricsRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActivityMetricsRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActivityMetricsRequestStatusMt> for ActivityMetricsRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActivityMetricsRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActivityMetricsRequestStatusMt> for ActivityMetricsRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActivityMetricsRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActivityMetricsRequestStatusMt> for ActivityMetricsRequestStatus {
	fn from(p: crate::v2_5::types::ActivityMetricsRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActivityMetricsRequestStatusMt> for ActivityMetricsRequestStatus {
	fn into(self) -> crate::v2_5::types::ActivityMetricsRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies planned *Capability-related activities for a System, independent of System kinematics.  Activities are the planned implementation details of Effects, Actions, Tasks, Capability Commands, etc.  Activity planning can be done manually by operators, by an activity planning service or a combination.  This message decouples activity planning from allocation, kinematic and other types of planning; the ActivityPlan of a System can be created, updated and approved independent of other *Plans.  It enables any type of *Plan to be a constraint on activity planning.
An ActivityPlan can be an input and/or output of planning processes.  For example an ActivityPlan from a previous round of planning could be an input to an activity planning service that adds additional planned activities to it.
A single System can have multiple independent ActivityPlans for different Task, Capability, sensor, etc. types; that are developed by one or more services across a multi-System service oriented architecture; at different times then independently updated and approved.  Optionally, all types of activities for a System can be included in a single ActivityPlan.
An ActivityPlan can be created discretely or as part of a MissionPlan that includes other *Plans.  An ActivityPlan can only be activated and executed as part of a MissionPlan.  A MissionPlan can be used to plan the execution order of multiple ActivityPlans and *Plans in general.  An ActivityPlan can be subject to approval per Approval* messages.  Planning, approval, activation and execution state information for an ActivityPlan are given in other ActivityPlan* messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActivityPlan(
	pub crate::v2_5::types::ActivityPlanMt,
);
impl Deref for ActivityPlan {
	type Target = crate::v2_5::types::ActivityPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActivityPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActivityPlanMt> for ActivityPlan {
	fn as_ref(&self) -> &crate::v2_5::types::ActivityPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActivityPlanMt> for ActivityPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActivityPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActivityPlanMt> for ActivityPlan {
	fn from(p: crate::v2_5::types::ActivityPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActivityPlanMt> for ActivityPlan {
	fn into(self) -> crate::v2_5::types::ActivityPlanMt {
		self.0
	}
}


#[doc = r#"This message indicates the current state in an approval state machine for an ActivityPlan.  Approval may or may not be required.  If required, there may be many approvers.  This message provides current approval status regardless of how it was given.  This message is not to be used to indicate approval for individual activities within the ActivityPlan, only the whole plan.
ActivityPlan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are ActivityPlanStatus, ActivityPlanApprovalStatus, ActivityPlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActivityPlanApprovalStatus(
	pub crate::v2_5::types::ActivityPlanApprovalStatusMt,
);
impl Deref for ActivityPlanApprovalStatus {
	type Target = crate::v2_5::types::ActivityPlanApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActivityPlanApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActivityPlanApprovalStatusMt> for ActivityPlanApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActivityPlanApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActivityPlanApprovalStatusMt> for ActivityPlanApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActivityPlanApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActivityPlanApprovalStatusMt> for ActivityPlanApprovalStatus {
	fn from(p: crate::v2_5::types::ActivityPlanApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActivityPlanApprovalStatusMt> for ActivityPlanApprovalStatus {
	fn into(self) -> crate::v2_5::types::ActivityPlanApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message commands an ActivityPlan related planning function/action.  Example planning functions include updating an existing ActivityPlan, creating a new ActivityPlan or combining/stitching existing ActivityPlans together.  The command includes many inputs to the planning function while others may come from a variety of other messages.  The expected output of the planning function is an ActivityPlan message.
The command includes options for constraining the planning function in a variety of ways using existing plans of the same type or by other plan types.  For example, an ActivityPlan could be constrained by a previous ActivityPlan and/or a TaskPlan.
The command includes environment overrides to selectively modify details of the current planning environment in the context of a single planning command. For example, a known threat Entity in the environment could be removed and an expected Entity could be for added to the environment in the context of a single planning command in support of speculative or "what-if"  contingency planning.
The command includes settings for "weightings" that influence the decisions of operators or planning algorithms performing the planning.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActivityPlanCommand(
	pub crate::v2_5::types::ActivityPlanCommandMt,
);
impl Deref for ActivityPlanCommand {
	type Target = crate::v2_5::types::ActivityPlanCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActivityPlanCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActivityPlanCommandMt> for ActivityPlanCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ActivityPlanCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActivityPlanCommandMt> for ActivityPlanCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActivityPlanCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActivityPlanCommandMt> for ActivityPlanCommand {
	fn from(p: crate::v2_5::types::ActivityPlanCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActivityPlanCommandMt> for ActivityPlanCommand {
	fn into(self) -> crate::v2_5::types::ActivityPlanCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to create/update an ActivityPlan, including the current state in a command and processing state machine; see the ActivityPlanCommand message.  Creation/update of an ActivityPlan may occur autonomously, without an ActivityPlanCommand, in which case the current state of the plan could be given in the ActivityPlanStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActivityPlanCommandStatus(
	pub crate::v2_5::types::ActivityPlanCommandStatusMt,
);
impl Deref for ActivityPlanCommandStatus {
	type Target = crate::v2_5::types::ActivityPlanCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActivityPlanCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActivityPlanCommandStatusMt> for ActivityPlanCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActivityPlanCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActivityPlanCommandStatusMt> for ActivityPlanCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActivityPlanCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActivityPlanCommandStatusMt> for ActivityPlanCommandStatus {
	fn from(p: crate::v2_5::types::ActivityPlanCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActivityPlanCommandStatusMt> for ActivityPlanCommandStatus {
	fn into(self) -> crate::v2_5::types::ActivityPlanCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the current state in an execution state machine for one or more current and/or previous ActivityPlans both as a whole and for individual Activities.  Plan execution begins after successful autonomous plan activation or activation via the MissionPlanActivation messages.  This message provides execution status regardless of how execution was initiated.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActivityPlanExecutionStatus(
	pub crate::v2_5::types::ActivityPlanExecutionStatusMt,
);
impl Deref for ActivityPlanExecutionStatus {
	type Target = crate::v2_5::types::ActivityPlanExecutionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActivityPlanExecutionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActivityPlanExecutionStatusMt> for ActivityPlanExecutionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActivityPlanExecutionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActivityPlanExecutionStatusMt> for ActivityPlanExecutionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActivityPlanExecutionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActivityPlanExecutionStatusMt> for ActivityPlanExecutionStatus {
	fn from(p: crate::v2_5::types::ActivityPlanExecutionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActivityPlanExecutionStatusMt> for ActivityPlanExecutionStatus {
	fn into(self) -> crate::v2_5::types::ActivityPlanExecutionStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the current state in a planning and plan validation state machine for an ActivityPlan.  Planning and validation may occur autonomously or be commanded.  In the former case, there is no command status message indicating the resulting state.  This message provides current status regardless of how status changes were triggered.  This message is not to be used to status individual activities within the ActivityPlan, only the whole plan.
ActivityPlan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are ActivityPlanStatus, ActivityPlanApprovalStatus, ActivityPlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActivityPlanStatus(
	pub crate::v2_5::types::ActivityPlanStatusMt,
);
impl Deref for ActivityPlanStatus {
	type Target = crate::v2_5::types::ActivityPlanStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActivityPlanStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActivityPlanStatusMt> for ActivityPlanStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActivityPlanStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActivityPlanStatusMt> for ActivityPlanStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActivityPlanStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActivityPlanStatusMt> for ActivityPlanStatus {
	fn from(p: crate::v2_5::types::ActivityPlanStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActivityPlanStatusMt> for ActivityPlanStatus {
	fn into(self) -> crate::v2_5::types::ActivityPlanStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the validation, including the current state in a validation state machine, and details of invalid items. Validation may occur periodically, or onesie twosie. See the ActivityPlanValidationCommand message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActivityPlanValidation(
	pub crate::v2_5::types::ActivityPlanValidationMt,
);
impl Deref for ActivityPlanValidation {
	type Target = crate::v2_5::types::ActivityPlanValidationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActivityPlanValidation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActivityPlanValidationMt> for ActivityPlanValidation {
	fn as_ref(&self) -> &crate::v2_5::types::ActivityPlanValidationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActivityPlanValidationMt> for ActivityPlanValidation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActivityPlanValidationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActivityPlanValidationMt> for ActivityPlanValidation {
	fn from(p: crate::v2_5::types::ActivityPlanValidationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActivityPlanValidationMt> for ActivityPlanValidation {
	fn into(self) -> crate::v2_5::types::ActivityPlanValidationMt {
		self.0
	}
}


#[doc = r#"This message commands validation or re-validation of an existing ActivityPlan.  This message enables plan validation to happen as a separate step, distinct from plan creation.  For example, a plan could be created manually by an operator then machine validated against performance models and other conditions.  Additionally, this message enables an existing valid plan to be revalidated against updated battlespace conditions.  Finally this message optionally allows the existing plan to be updated when invalid items/portions are found.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActivityPlanValidationCommand(
	pub crate::v2_5::types::ActivityPlanValidationCommandMt,
);
impl Deref for ActivityPlanValidationCommand {
	type Target = crate::v2_5::types::ActivityPlanValidationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActivityPlanValidationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActivityPlanValidationCommandMt> for ActivityPlanValidationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ActivityPlanValidationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActivityPlanValidationCommandMt> for ActivityPlanValidationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActivityPlanValidationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActivityPlanValidationCommandMt> for ActivityPlanValidationCommand {
	fn from(p: crate::v2_5::types::ActivityPlanValidationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActivityPlanValidationCommandMt> for ActivityPlanValidationCommand {
	fn into(self) -> crate::v2_5::types::ActivityPlanValidationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to validate an ActivityPlan, including the current state in a command and processing state machine.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ActivityPlanValidationCommandStatus(
	pub crate::v2_5::types::ActivityPlanValidationCommandStatusMt,
);
impl Deref for ActivityPlanValidationCommandStatus {
	type Target = crate::v2_5::types::ActivityPlanValidationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ActivityPlanValidationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ActivityPlanValidationCommandStatusMt> for ActivityPlanValidationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ActivityPlanValidationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ActivityPlanValidationCommandStatusMt> for ActivityPlanValidationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ActivityPlanValidationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ActivityPlanValidationCommandStatusMt> for ActivityPlanValidationCommandStatus {
	fn from(p: crate::v2_5::types::ActivityPlanValidationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ActivityPlanValidationCommandStatusMt> for ActivityPlanValidationCommandStatus {
	fn into(self) -> crate::v2_5::types::ActivityPlanValidationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message contains a representation of an Air (Equipment) Record within an Order of Battle.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AirRecord(
	pub crate::v2_5::types::AirRecordMt,
);
impl Deref for AirRecord {
	type Target = crate::v2_5::types::AirRecordMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AirRecord {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AirRecordMt> for AirRecord {
	fn as_ref(&self) -> &crate::v2_5::types::AirRecordMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AirRecordMt> for AirRecord {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AirRecordMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AirRecordMt> for AirRecord {
	fn from(p: crate::v2_5::types::AirRecordMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AirRecordMt> for AirRecord {
	fn into(self) -> crate::v2_5::types::AirRecordMt {
		self.0
	}
}


#[doc = r#"This message describes dynamic performance characteristics for an instance of air domain equipment such as an aircraft.  The term "report" is used to indicate it is a dynamic description of equipment characteristics as opposed to the static characteristics respresented by AirRecord, AirEquipment and related UCI concepts.

Missile-related reports are described in a separate message due to their multi-domain nature.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AirReport(
	pub crate::v2_5::types::AirReportMt,
);
impl Deref for AirReport {
	type Target = crate::v2_5::types::AirReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AirReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AirReportMt> for AirReport {
	fn as_ref(&self) -> &crate::v2_5::types::AirReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AirReportMt> for AirReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AirReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AirReportMt> for AirReport {
	fn from(p: crate::v2_5::types::AirReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AirReportMt> for AirReport {
	fn into(self) -> crate::v2_5::types::AirReportMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the AirSample Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (AirSampleCommand) from an Operator or Capability management Service, 3) currently in-work AirSample, 4) AirSample scheduled for the future and 5) AirSample that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single AirSampleCommand or other triggering event can result in multiple activities within the AirSampleActivity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AirSampleActivity(
	pub crate::v2_5::types::AirSampleActivityMt,
);
impl Deref for AirSampleActivity {
	type Target = crate::v2_5::types::AirSampleActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AirSampleActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AirSampleActivityMt> for AirSampleActivity {
	fn as_ref(&self) -> &crate::v2_5::types::AirSampleActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AirSampleActivityMt> for AirSampleActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AirSampleActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AirSampleActivityMt> for AirSampleActivity {
	fn from(p: crate::v2_5::types::AirSampleActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AirSampleActivityMt> for AirSampleActivity {
	fn into(self) -> crate::v2_5::types::AirSampleActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the AirSample category of UCI Capability.  AirSample includes direct sampling of the air and remote sensing with spectral analysis with the intent of detecting chemical, biological, radiological, nuclear or explosive (CBRNE) events.  This message "advertises" the mostly static characteristics of a mission-ready AirSample Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AirSampleCapability(
	pub crate::v2_5::types::AirSampleCapabilityMt,
);
impl Deref for AirSampleCapability {
	type Target = crate::v2_5::types::AirSampleCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AirSampleCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AirSampleCapabilityMt> for AirSampleCapability {
	fn as_ref(&self) -> &crate::v2_5::types::AirSampleCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AirSampleCapabilityMt> for AirSampleCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AirSampleCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AirSampleCapabilityMt> for AirSampleCapability {
	fn from(p: crate::v2_5::types::AirSampleCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AirSampleCapabilityMt> for AirSampleCapability {
	fn into(self) -> crate::v2_5::types::AirSampleCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Air Sampling capabilities available to the system.   This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, vehicle flight profiles, etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AirSampleCapabilityStatus(
	pub crate::v2_5::types::AirSampleCapabilityStatusMt,
);
impl Deref for AirSampleCapabilityStatus {
	type Target = crate::v2_5::types::AirSampleCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AirSampleCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AirSampleCapabilityStatusMt> for AirSampleCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AirSampleCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AirSampleCapabilityStatusMt> for AirSampleCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AirSampleCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AirSampleCapabilityStatusMt> for AirSampleCapabilityStatus {
	fn from(p: crate::v2_5::types::AirSampleCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AirSampleCapabilityStatusMt> for AirSampleCapabilityStatus {
	fn into(self) -> crate::v2_5::types::AirSampleCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the AirSample form of the general UCI Capability Command.  It is used to manually invoke an AirSample Capability to perform a new AirSample Activity or change an existing interactive AirSample Activity.  It differs from an AirSample Task because it is intended for direct interaction with the host of the Capability, not a planning Service, and therefore is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan.  Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages.  Capability Commands can be used in parallel with Tasks, but are generally deferential to them.  However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AirSampleCommand(
	pub crate::v2_5::types::AirSampleCommandMt,
);
impl Deref for AirSampleCommand {
	type Target = crate::v2_5::types::AirSampleCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AirSampleCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AirSampleCommandMt> for AirSampleCommand {
	fn as_ref(&self) -> &crate::v2_5::types::AirSampleCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AirSampleCommandMt> for AirSampleCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AirSampleCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AirSampleCommandMt> for AirSampleCommand {
	fn from(p: crate::v2_5::types::AirSampleCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AirSampleCommandMt> for AirSampleCommand {
	fn into(self) -> crate::v2_5::types::AirSampleCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an AirSampleCommand.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the AirSampleActivity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AirSampleCommandStatus(
	pub crate::v2_5::types::AirSampleCommandStatusMt,
);
impl Deref for AirSampleCommandStatus {
	type Target = crate::v2_5::types::AirSampleCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AirSampleCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AirSampleCommandStatusMt> for AirSampleCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AirSampleCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AirSampleCommandStatusMt> for AirSampleCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AirSampleCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AirSampleCommandStatusMt> for AirSampleCommandStatus {
	fn from(p: crate::v2_5::types::AirSampleCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AirSampleCommandStatusMt> for AirSampleCommandStatus {
	fn into(self) -> crate::v2_5::types::AirSampleCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the AirSample Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AirSampleSettingsCommand(
	pub crate::v2_5::types::AirSampleSettingsCommandMt,
);
impl Deref for AirSampleSettingsCommand {
	type Target = crate::v2_5::types::AirSampleSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AirSampleSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AirSampleSettingsCommandMt> for AirSampleSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::AirSampleSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AirSampleSettingsCommandMt> for AirSampleSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AirSampleSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AirSampleSettingsCommandMt> for AirSampleSettingsCommand {
	fn from(p: crate::v2_5::types::AirSampleSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AirSampleSettingsCommandMt> for AirSampleSettingsCommand {
	fn into(self) -> crate::v2_5::types::AirSampleSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message reports the acknowledgment and/or acceptance of an Air Sample settings command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AirSampleSettingsCommandStatus(
	pub crate::v2_5::types::AirSampleSettingsCommandStatusMt,
);
impl Deref for AirSampleSettingsCommandStatus {
	type Target = crate::v2_5::types::AirSampleSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AirSampleSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AirSampleSettingsCommandStatusMt> for AirSampleSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AirSampleSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AirSampleSettingsCommandStatusMt> for AirSampleSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AirSampleSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AirSampleSettingsCommandStatusMt> for AirSampleSettingsCommandStatus {
	fn from(p: crate::v2_5::types::AirSampleSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AirSampleSettingsCommandStatusMt> for AirSampleSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::AirSampleSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of an airfield.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AirfieldReport(
	pub crate::v2_5::types::AirfieldReportMt,
);
impl Deref for AirfieldReport {
	type Target = crate::v2_5::types::AirfieldReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AirfieldReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AirfieldReportMt> for AirfieldReport {
	fn as_ref(&self) -> &crate::v2_5::types::AirfieldReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AirfieldReportMt> for AirfieldReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AirfieldReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AirfieldReportMt> for AirfieldReport {
	fn from(p: crate::v2_5::types::AirfieldReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AirfieldReportMt> for AirfieldReport {
	fn into(self) -> crate::v2_5::types::AirfieldReportMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the AMTI Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (AMTI_Command) from an Operator or Capability management Service, 3) currently in-work AMTI, 4) AMTI scheduled for the future and 5) AMTI that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single AMTI_Command or other triggering event can result in multiple activities within the AMTI_Activity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AmtiActivity(
	pub crate::v2_5::types::AmtiActivityMt,
);
impl Deref for AmtiActivity {
	type Target = crate::v2_5::types::AmtiActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AmtiActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AmtiActivityMt> for AmtiActivity {
	fn as_ref(&self) -> &crate::v2_5::types::AmtiActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AmtiActivityMt> for AmtiActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AmtiActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AmtiActivityMt> for AmtiActivity {
	fn from(p: crate::v2_5::types::AmtiActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AmtiActivityMt> for AmtiActivity {
	fn into(self) -> crate::v2_5::types::AmtiActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the AMTI (Airborne Moving Target Indicator) category of UCI Capability.  AMTI detects aircraft through active radar search and track.  This message "advertises" the mostly static characteristics of a mission-ready AMTI Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AmtiCapability(
	pub crate::v2_5::types::AmtiCapabilityMt,
);
impl Deref for AmtiCapability {
	type Target = crate::v2_5::types::AmtiCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AmtiCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AmtiCapabilityMt> for AmtiCapability {
	fn as_ref(&self) -> &crate::v2_5::types::AmtiCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AmtiCapabilityMt> for AmtiCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AmtiCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AmtiCapabilityMt> for AmtiCapability {
	fn from(p: crate::v2_5::types::AmtiCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AmtiCapabilityMt> for AmtiCapability {
	fn into(self) -> crate::v2_5::types::AmtiCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the AMTI capabilities available to the system.   This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc.  Since AMTI capabilities refer specifically to an active capability, an EMCON restriction can result in the AMTI capabilities being temporarily unavailable.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AmtiCapabilityStatus(
	pub crate::v2_5::types::AmtiCapabilityStatusMt,
);
impl Deref for AmtiCapabilityStatus {
	type Target = crate::v2_5::types::AmtiCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AmtiCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AmtiCapabilityStatusMt> for AmtiCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AmtiCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AmtiCapabilityStatusMt> for AmtiCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AmtiCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AmtiCapabilityStatusMt> for AmtiCapabilityStatus {
	fn from(p: crate::v2_5::types::AmtiCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AmtiCapabilityStatusMt> for AmtiCapabilityStatus {
	fn into(self) -> crate::v2_5::types::AmtiCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the AMTI (Airborne Moving Target Indicator) form of the general UCI Capability Command.  AMTI is a radar Capability that includes active transmission of RF signals.  It is used to manually invoke an AMTI Capability to perform a new AMTI Activity or to make a change to an existing interactive AMTI Activity.  It differs from an AMTI Task because it is intended for direct interaction with the host of the Capability and is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan.  Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages.  Capability Commands can be used in parallel with Tasks, but are generally deferential to them.  However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AmtiCommand(
	pub crate::v2_5::types::AmtiCommandMt,
);
impl Deref for AmtiCommand {
	type Target = crate::v2_5::types::AmtiCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AmtiCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AmtiCommandMt> for AmtiCommand {
	fn as_ref(&self) -> &crate::v2_5::types::AmtiCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AmtiCommandMt> for AmtiCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AmtiCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AmtiCommandMt> for AmtiCommand {
	fn from(p: crate::v2_5::types::AmtiCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AmtiCommandMt> for AmtiCommand {
	fn into(self) -> crate::v2_5::types::AmtiCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an AMTI_Command.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the AMTI_Activity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AmtiCommandStatus(
	pub crate::v2_5::types::AmtiCommandStatusMt,
);
impl Deref for AmtiCommandStatus {
	type Target = crate::v2_5::types::AmtiCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AmtiCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AmtiCommandStatusMt> for AmtiCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AmtiCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AmtiCommandStatusMt> for AmtiCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AmtiCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AmtiCommandStatusMt> for AmtiCommandStatus {
	fn from(p: crate::v2_5::types::AmtiCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AmtiCommandStatusMt> for AmtiCommandStatus {
	fn into(self) -> crate::v2_5::types::AmtiCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the AMTI Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AmtiSettingsCommand(
	pub crate::v2_5::types::AmtiSettingsCommandMt,
);
impl Deref for AmtiSettingsCommand {
	type Target = crate::v2_5::types::AmtiSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AmtiSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AmtiSettingsCommandMt> for AmtiSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::AmtiSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AmtiSettingsCommandMt> for AmtiSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AmtiSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AmtiSettingsCommandMt> for AmtiSettingsCommand {
	fn from(p: crate::v2_5::types::AmtiSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AmtiSettingsCommandMt> for AmtiSettingsCommand {
	fn into(self) -> crate::v2_5::types::AmtiSettingsCommandMt {
		self.0
	}
}


#[doc = r#"Reports the acknowledgment and/or acceptance of an AMTI settings command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AmtiSettingsCommandStatus(
	pub crate::v2_5::types::AmtiSettingsCommandStatusMt,
);
impl Deref for AmtiSettingsCommandStatus {
	type Target = crate::v2_5::types::AmtiSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AmtiSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AmtiSettingsCommandStatusMt> for AmtiSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AmtiSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AmtiSettingsCommandStatusMt> for AmtiSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AmtiSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AmtiSettingsCommandStatusMt> for AmtiSettingsCommandStatus {
	fn from(p: crate::v2_5::types::AmtiSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AmtiSettingsCommandStatusMt> for AmtiSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::AmtiSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message provides a route to be used for analysis and optionally includes position data as would be flown for each path segment.  An AnalysisRoute could be used as an input to an AssessmentRequest or a RoutePlanValidationCommand.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AnalysisRoute(
	pub crate::v2_5::types::AnalysisRouteMt,
);
impl Deref for AnalysisRoute {
	type Target = crate::v2_5::types::AnalysisRouteMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AnalysisRoute {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AnalysisRouteMt> for AnalysisRoute {
	fn as_ref(&self) -> &crate::v2_5::types::AnalysisRouteMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AnalysisRouteMt> for AnalysisRoute {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AnalysisRouteMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AnalysisRouteMt> for AnalysisRoute {
	fn from(p: crate::v2_5::types::AnalysisRouteMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AnalysisRouteMt> for AnalysisRoute {
	fn into(self) -> crate::v2_5::types::AnalysisRouteMt {
		self.0
	}
}


#[doc = r#"This message provides a propagated route for an existing route plan.  An AnalysisRoute could be used as an input to an AssessmentRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AnalysisRouteRequest(
	pub crate::v2_5::types::AnalysisRouteRequestMt,
);
impl Deref for AnalysisRouteRequest {
	type Target = crate::v2_5::types::AnalysisRouteRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AnalysisRouteRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AnalysisRouteRequestMt> for AnalysisRouteRequest {
	fn as_ref(&self) -> &crate::v2_5::types::AnalysisRouteRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AnalysisRouteRequestMt> for AnalysisRouteRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AnalysisRouteRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AnalysisRouteRequestMt> for AnalysisRouteRequest {
	fn from(p: crate::v2_5::types::AnalysisRouteRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AnalysisRouteRequestMt> for AnalysisRouteRequest {
	fn into(self) -> crate::v2_5::types::AnalysisRouteRequestMt {
		self.0
	}
}


#[doc = r#"This message provides a propagated route for an existing route plan.  An AnalysisRoute could be used as an input to an AssessmentRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AnalysisRouteRequestStatus(
	pub crate::v2_5::types::AnalysisRouteRequestStatusMt,
);
impl Deref for AnalysisRouteRequestStatus {
	type Target = crate::v2_5::types::AnalysisRouteRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AnalysisRouteRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AnalysisRouteRequestStatusMt> for AnalysisRouteRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AnalysisRouteRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AnalysisRouteRequestStatusMt> for AnalysisRouteRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AnalysisRouteRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AnalysisRouteRequestStatusMt> for AnalysisRouteRequestStatus {
	fn from(p: crate::v2_5::types::AnalysisRouteRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AnalysisRouteRequestStatusMt> for AnalysisRouteRequestStatus {
	fn into(self) -> crate::v2_5::types::AnalysisRouteRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the AO Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (AO_Command) from an Operator or Capability management Service, 3) currently in-work AO, 4) AO scheduled for the future and 5) AO that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single AO_Command or other triggering event can result in multiple activities within the AO_Activity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AoActivity(
	pub crate::v2_5::types::AoActivityMt,
);
impl Deref for AoActivity {
	type Target = crate::v2_5::types::AoActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AoActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AoActivityMt> for AoActivity {
	fn as_ref(&self) -> &crate::v2_5::types::AoActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AoActivityMt> for AoActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AoActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AoActivityMt> for AoActivity {
	fn from(p: crate::v2_5::types::AoActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AoActivityMt> for AoActivity {
	fn into(self) -> crate::v2_5::types::AoActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the AO (Active Optical) category of UCI Capability.  This message "advertises" the mostly static characteristics of a mission-ready AO Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AoCapability(
	pub crate::v2_5::types::AoCapabilityMt,
);
impl Deref for AoCapability {
	type Target = crate::v2_5::types::AoCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AoCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AoCapabilityMt> for AoCapability {
	fn as_ref(&self) -> &crate::v2_5::types::AoCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AoCapabilityMt> for AoCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AoCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AoCapabilityMt> for AoCapability {
	fn from(p: crate::v2_5::types::AoCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AoCapabilityMt> for AoCapability {
	fn into(self) -> crate::v2_5::types::AoCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the AO capabilities available to the system.   This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc.  Since AO capabilities refer specifically to an active capability, an EMCON restriction can result in the AO capabilities being temporarily unavailable.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AoCapabilityStatus(
	pub crate::v2_5::types::AoCapabilityStatusMt,
);
impl Deref for AoCapabilityStatus {
	type Target = crate::v2_5::types::AoCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AoCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AoCapabilityStatusMt> for AoCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AoCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AoCapabilityStatusMt> for AoCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AoCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AoCapabilityStatusMt> for AoCapabilityStatus {
	fn from(p: crate::v2_5::types::AoCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AoCapabilityStatusMt> for AoCapabilityStatus {
	fn into(self) -> crate::v2_5::types::AoCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the AO (Active Optical) form of the general UCI Capability Command.  It is used to manually invoke an Active Optical Capability (such as a laser designation) to perform a new AO Activity or change an existing interactive AO Activity.  It differs from an AO Task because it is intended for direct interaction with the host of the Capability, not a planning Service, and therefore is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan.  Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages.  Capability Commands can be used in parallel with Tasks, but are generally deferential to them.  However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AoCommand(
	pub crate::v2_5::types::AoCommandMt,
);
impl Deref for AoCommand {
	type Target = crate::v2_5::types::AoCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AoCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AoCommandMt> for AoCommand {
	fn as_ref(&self) -> &crate::v2_5::types::AoCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AoCommandMt> for AoCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AoCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AoCommandMt> for AoCommand {
	fn from(p: crate::v2_5::types::AoCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AoCommandMt> for AoCommand {
	fn into(self) -> crate::v2_5::types::AoCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an AO_Command.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the AO_Activity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AoCommandStatus(
	pub crate::v2_5::types::AoCommandStatusMt,
);
impl Deref for AoCommandStatus {
	type Target = crate::v2_5::types::AoCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AoCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AoCommandStatusMt> for AoCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AoCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AoCommandStatusMt> for AoCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AoCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AoCommandStatusMt> for AoCommandStatus {
	fn from(p: crate::v2_5::types::AoCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AoCommandStatusMt> for AoCommandStatus {
	fn into(self) -> crate::v2_5::types::AoCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to request consent to perform and Active Optical Activity.  Status for this command message is provided via the AO_ConsentRequestStatus message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AoConsentRequest(
	pub crate::v2_5::types::AoConsentRequestMt,
);
impl Deref for AoConsentRequest {
	type Target = crate::v2_5::types::AoConsentRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AoConsentRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AoConsentRequestMt> for AoConsentRequest {
	fn as_ref(&self) -> &crate::v2_5::types::AoConsentRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AoConsentRequestMt> for AoConsentRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AoConsentRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AoConsentRequestMt> for AoConsentRequest {
	fn from(p: crate::v2_5::types::AoConsentRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AoConsentRequestMt> for AoConsentRequest {
	fn into(self) -> crate::v2_5::types::AoConsentRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the consent request to perform an Active Optical Activity.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AoConsentRequestStatus(
	pub crate::v2_5::types::AoConsentRequestStatusMt,
);
impl Deref for AoConsentRequestStatus {
	type Target = crate::v2_5::types::AoConsentRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AoConsentRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AoConsentRequestStatusMt> for AoConsentRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AoConsentRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AoConsentRequestStatusMt> for AoConsentRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AoConsentRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AoConsentRequestStatusMt> for AoConsentRequestStatus {
	fn from(p: crate::v2_5::types::AoConsentRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AoConsentRequestStatusMt> for AoConsentRequestStatus {
	fn into(self) -> crate::v2_5::types::AoConsentRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the AO Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AoSettingsCommand(
	pub crate::v2_5::types::AoSettingsCommandMt,
);
impl Deref for AoSettingsCommand {
	type Target = crate::v2_5::types::AoSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AoSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AoSettingsCommandMt> for AoSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::AoSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AoSettingsCommandMt> for AoSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AoSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AoSettingsCommandMt> for AoSettingsCommand {
	fn from(p: crate::v2_5::types::AoSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AoSettingsCommandMt> for AoSettingsCommand {
	fn into(self) -> crate::v2_5::types::AoSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of an AO settings command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AoSettingsCommandStatus(
	pub crate::v2_5::types::AoSettingsCommandStatusMt,
);
impl Deref for AoSettingsCommandStatus {
	type Target = crate::v2_5::types::AoSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AoSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AoSettingsCommandStatusMt> for AoSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AoSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AoSettingsCommandStatusMt> for AoSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AoSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AoSettingsCommandStatusMt> for AoSettingsCommandStatus {
	fn from(p: crate::v2_5::types::AoSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AoSettingsCommandStatusMt> for AoSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::AoSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message assigns ApprovalPolicy to a System or Systems and specifies which System or Systems is the approval authority for that policy.  An approval authority is responsible for approving or rejecting activities specified in the ApprovalPolicy for the specified System.  See the annotations for the ApprovalPolicy message for an overview of the entire Approval* series of messages.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ApprovalAuthority(
	pub crate::v2_5::types::ApprovalAuthorityMt,
);
impl Deref for ApprovalAuthority {
	type Target = crate::v2_5::types::ApprovalAuthorityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ApprovalAuthority {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ApprovalAuthorityMt> for ApprovalAuthority {
	fn as_ref(&self) -> &crate::v2_5::types::ApprovalAuthorityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ApprovalAuthorityMt> for ApprovalAuthority {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ApprovalAuthorityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ApprovalAuthorityMt> for ApprovalAuthority {
	fn from(p: crate::v2_5::types::ApprovalAuthorityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ApprovalAuthorityMt> for ApprovalAuthority {
	fn into(self) -> crate::v2_5::types::ApprovalAuthorityMt {
		self.0
	}
}


#[doc = r#"This message requests assignment of ApprovalPolicy to a System or Systems and a corresponding approval authority for that policy.  See the annotations for the ApprovalPolicy message for an overview of the entire Approval* series of messages.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ApprovalAuthorityRequest(
	pub crate::v2_5::types::ApprovalAuthorityRequestMt,
);
impl Deref for ApprovalAuthorityRequest {
	type Target = crate::v2_5::types::ApprovalAuthorityRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ApprovalAuthorityRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ApprovalAuthorityRequestMt> for ApprovalAuthorityRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ApprovalAuthorityRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ApprovalAuthorityRequestMt> for ApprovalAuthorityRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ApprovalAuthorityRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ApprovalAuthorityRequestMt> for ApprovalAuthorityRequest {
	fn from(p: crate::v2_5::types::ApprovalAuthorityRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ApprovalAuthorityRequestMt> for ApprovalAuthorityRequest {
	fn into(self) -> crate::v2_5::types::ApprovalAuthorityRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to an ApprovalAuthorityRequest.  See the annotations for the ApprovalPolicy message for an overview of the entire Approval* series of messages.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ApprovalAuthorityRequestStatus(
	pub crate::v2_5::types::ApprovalAuthorityRequestStatusMt,
);
impl Deref for ApprovalAuthorityRequestStatus {
	type Target = crate::v2_5::types::ApprovalAuthorityRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ApprovalAuthorityRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ApprovalAuthorityRequestStatusMt> for ApprovalAuthorityRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ApprovalAuthorityRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ApprovalAuthorityRequestStatusMt> for ApprovalAuthorityRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ApprovalAuthorityRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ApprovalAuthorityRequestStatusMt> for ApprovalAuthorityRequestStatus {
	fn from(p: crate::v2_5::types::ApprovalAuthorityRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ApprovalAuthorityRequestStatusMt> for ApprovalAuthorityRequestStatus {
	fn into(self) -> crate::v2_5::types::ApprovalAuthorityRequestStatusMt {
		self.0
	}
}


#[doc = r#"Indicates a command for on demand approval management processing for a given approvable item.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ApprovalManagementCommand(
	pub crate::v2_5::types::ApprovalManagementCommandMt,
);
impl Deref for ApprovalManagementCommand {
	type Target = crate::v2_5::types::ApprovalManagementCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ApprovalManagementCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ApprovalManagementCommandMt> for ApprovalManagementCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ApprovalManagementCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ApprovalManagementCommandMt> for ApprovalManagementCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ApprovalManagementCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ApprovalManagementCommandMt> for ApprovalManagementCommand {
	fn from(p: crate::v2_5::types::ApprovalManagementCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ApprovalManagementCommandMt> for ApprovalManagementCommand {
	fn into(self) -> crate::v2_5::types::ApprovalManagementCommandMt {
		self.0
	}
}


#[doc = r#"An Approval Management Command status is used by a service to report status/state of an ApprovalManagementCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ApprovalManagementCommandStatus(
	pub crate::v2_5::types::ApprovalManagementCommandStatusMt,
);
impl Deref for ApprovalManagementCommandStatus {
	type Target = crate::v2_5::types::ApprovalManagementCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ApprovalManagementCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ApprovalManagementCommandStatusMt> for ApprovalManagementCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ApprovalManagementCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ApprovalManagementCommandStatusMt> for ApprovalManagementCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ApprovalManagementCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ApprovalManagementCommandStatusMt> for ApprovalManagementCommandStatus {
	fn from(p: crate::v2_5::types::ApprovalManagementCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ApprovalManagementCommandStatusMt> for ApprovalManagementCommandStatus {
	fn into(self) -> crate::v2_5::types::ApprovalManagementCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies which activities of a system require approval from an approval authority.  The Approval* series of messages are designed to request and establish an approval hierarchy that governs select, possibly automated, activities of the UCI family of services such as route planning and task execution.  They can be used collectively to support a variety of activity approval use cases by separating data content into independent messages aligned with typical use case actors.  As an example, one System could create/manage ApprovalPolicy while another could assign them to Systems and assign approval authorities via the ApprovalAuthority message.  Then, one or more other Systems could make ApprovalRequests based on the ApprovalPolicy.  Finally, the System or Systems assigned by ApprovalAuthority approve or reject the ApprovalRequest using ApprovalRequestStatus.  The messages allow multiple approval authorities per ApprovalPolicy and/or multiple ApprovalPolicy per System.  When multiple ApprovalPolicy apply to a single System, they should be evaluated independently; if any policy requires approval for a certain condition then approval is necessary; if multiple policies required approval for a certain condition then approval should be requested for each.  The messages PlanningFunction*, Approval*, MissionContingencyAlert and ControlStatus are closely related.  They use a common taxonomy of autonomous functions (task allocation, route planning, mission activation and mission execution), triggers for those functions (new threats, new zones, failures, etc.) and results of those functions (dropped Tasks, changes in vulnerability, etc.).  ControlStatus indicates the full set of available autonomous functions/settings of a System.  PlanningFunction* indicates how the available settings are currently configured.  MissionContingencyAlert indicates an autonomous function/setting that has been triggered.  Approval* messages allow Operators to approve the results of autonomous responses as needed.  Updates supersede previous  or instances of the message; each instance of the message shall have a complete specification of the approval policy.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ApprovalPolicy(
	pub crate::v2_5::types::ApprovalPolicyMt,
);
impl Deref for ApprovalPolicy {
	type Target = crate::v2_5::types::ApprovalPolicyMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ApprovalPolicy {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ApprovalPolicyMt> for ApprovalPolicy {
	fn as_ref(&self) -> &crate::v2_5::types::ApprovalPolicyMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ApprovalPolicyMt> for ApprovalPolicy {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ApprovalPolicyMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ApprovalPolicyMt> for ApprovalPolicy {
	fn from(p: crate::v2_5::types::ApprovalPolicyMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ApprovalPolicyMt> for ApprovalPolicy {
	fn into(self) -> crate::v2_5::types::ApprovalPolicyMt {
		self.0
	}
}


#[doc = r#"This message is a request for approval of an activity specified in an associated ApprovalPolicy.  See the annotations for the ApprovalPolicy message for an overview of the entire Approval* series of messages.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ApprovalRequest(
	pub crate::v2_5::types::ApprovalRequestMt,
);
impl Deref for ApprovalRequest {
	type Target = crate::v2_5::types::ApprovalRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ApprovalRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ApprovalRequestMt> for ApprovalRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ApprovalRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ApprovalRequestMt> for ApprovalRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ApprovalRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ApprovalRequestMt> for ApprovalRequest {
	fn from(p: crate::v2_5::types::ApprovalRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ApprovalRequestMt> for ApprovalRequest {
	fn into(self) -> crate::v2_5::types::ApprovalRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to an ApprovalRequest.  See the annotations for the ApprovalPolicy message for an overview of the entire Approval* series of messages.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ApprovalRequestStatus(
	pub crate::v2_5::types::ApprovalRequestStatusMt,
);
impl Deref for ApprovalRequestStatus {
	type Target = crate::v2_5::types::ApprovalRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ApprovalRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ApprovalRequestStatusMt> for ApprovalRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ApprovalRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ApprovalRequestStatusMt> for ApprovalRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ApprovalRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ApprovalRequestStatusMt> for ApprovalRequestStatus {
	fn from(p: crate::v2_5::types::ApprovalRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ApprovalRequestStatusMt> for ApprovalRequestStatus {
	fn into(self) -> crate::v2_5::types::ApprovalRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message provides the results of an assessment. The types of assessments available are in AssessmentType.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Assessment(
	pub crate::v2_5::types::AssessmentMt,
);
impl Deref for Assessment {
	type Target = crate::v2_5::types::AssessmentMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Assessment {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AssessmentMt> for Assessment {
	fn as_ref(&self) -> &crate::v2_5::types::AssessmentMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AssessmentMt> for Assessment {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AssessmentMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AssessmentMt> for Assessment {
	fn from(p: crate::v2_5::types::AssessmentMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AssessmentMt> for Assessment {
	fn into(self) -> crate::v2_5::types::AssessmentMt {
		self.0
	}
}


#[doc = r#"This message is a request to generate an assessment. The types of assessments available are in AssessmentRequestType.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AssessmentRequest(
	pub crate::v2_5::types::AssessmentRequestMt,
);
impl Deref for AssessmentRequest {
	type Target = crate::v2_5::types::AssessmentRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AssessmentRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AssessmentRequestMt> for AssessmentRequest {
	fn as_ref(&self) -> &crate::v2_5::types::AssessmentRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AssessmentRequestMt> for AssessmentRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AssessmentRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AssessmentRequestMt> for AssessmentRequest {
	fn from(p: crate::v2_5::types::AssessmentRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AssessmentRequestMt> for AssessmentRequest {
	fn into(self) -> crate::v2_5::types::AssessmentRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to the request for an assessment.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AssessmentRequestStatus(
	pub crate::v2_5::types::AssessmentRequestStatusMt,
);
impl Deref for AssessmentRequestStatus {
	type Target = crate::v2_5::types::AssessmentRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AssessmentRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AssessmentRequestStatusMt> for AssessmentRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AssessmentRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AssessmentRequestStatusMt> for AssessmentRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AssessmentRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AssessmentRequestStatusMt> for AssessmentRequestStatus {
	fn from(p: crate::v2_5::types::AssessmentRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AssessmentRequestStatusMt> for AssessmentRequestStatus {
	fn into(self) -> crate::v2_5::types::AssessmentRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message establishes/assigns authorization to be a source of Requirements for a given System; to be a user of the System.  Authorization to use is not authorization to control; authorization to use is independent of the C2 hierarchy established via the Control* series of messages for a given System.  It is also independent of the approval hierarchy established via the Approval* series of messages.  For example, System1 could have mission control of System2 and have responsibility for approving System2's Tasks for execution but not be authorized to use System2.  Further, authorization to use a System has different meanings based on the type of System and its position in the C2 hierarchy.  For example, authorization for System3 to task System4, where System4 is a vehicle, means that Tasks created by System3 should only be allocated to System4 even if other capable siblings of System4 are available.  In another example, authorization for System5 to task System6, where System6 controls many Systems, each of which controls multiple vehicle Systems, means that Tasks created by System5 can be allocated to any System subordinate to System6.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Authorization(
	pub crate::v2_5::types::AuthorizationMt,
);
impl Deref for Authorization {
	type Target = crate::v2_5::types::AuthorizationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Authorization {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AuthorizationMt> for Authorization {
	fn as_ref(&self) -> &crate::v2_5::types::AuthorizationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AuthorizationMt> for Authorization {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AuthorizationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AuthorizationMt> for Authorization {
	fn from(p: crate::v2_5::types::AuthorizationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AuthorizationMt> for Authorization {
	fn into(self) -> crate::v2_5::types::AuthorizationMt {
		self.0
	}
}


#[doc = r#"This message is a request for authorization to be a source of Requirements for a given System; a request to be a user of the System.  See the related Authorization message for further details.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AuthorizationRequest(
	pub crate::v2_5::types::AuthorizationRequestMt,
);
impl Deref for AuthorizationRequest {
	type Target = crate::v2_5::types::AuthorizationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AuthorizationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AuthorizationRequestMt> for AuthorizationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::AuthorizationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AuthorizationRequestMt> for AuthorizationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AuthorizationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AuthorizationRequestMt> for AuthorizationRequest {
	fn from(p: crate::v2_5::types::AuthorizationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AuthorizationRequestMt> for AuthorizationRequest {
	fn into(self) -> crate::v2_5::types::AuthorizationRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of an AuthorizationRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct AuthorizationRequestStatus(
	pub crate::v2_5::types::AuthorizationRequestStatusMt,
);
impl Deref for AuthorizationRequestStatus {
	type Target = crate::v2_5::types::AuthorizationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for AuthorizationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::AuthorizationRequestStatusMt> for AuthorizationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::AuthorizationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::AuthorizationRequestStatusMt> for AuthorizationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::AuthorizationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::AuthorizationRequestStatusMt> for AuthorizationRequestStatus {
	fn from(p: crate::v2_5::types::AuthorizationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::AuthorizationRequestStatusMt> for AuthorizationRequestStatus {
	fn into(self) -> crate::v2_5::types::AuthorizationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message contains a dynamic estimate of the characteristics that define the area(s) covered by associated capabilities.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CapabilityCoverageArea(
	pub crate::v2_5::types::CapabilityCoverageAreaMt,
);
impl Deref for CapabilityCoverageArea {
	type Target = crate::v2_5::types::CapabilityCoverageAreaMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CapabilityCoverageArea {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CapabilityCoverageAreaMt> for CapabilityCoverageArea {
	fn as_ref(&self) -> &crate::v2_5::types::CapabilityCoverageAreaMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CapabilityCoverageAreaMt> for CapabilityCoverageArea {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CapabilityCoverageAreaMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CapabilityCoverageAreaMt> for CapabilityCoverageArea {
	fn from(p: crate::v2_5::types::CapabilityCoverageAreaMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CapabilityCoverageAreaMt> for CapabilityCoverageArea {
	fn into(self) -> crate::v2_5::types::CapabilityCoverageAreaMt {
		self.0
	}
}


#[doc = r#"This message contains a request for the characteristics that identify and describe a capability coverage area.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CapabilityCoverageAreaRequest(
	pub crate::v2_5::types::CapabilityCoverageAreaRequestMt,
);
impl Deref for CapabilityCoverageAreaRequest {
	type Target = crate::v2_5::types::CapabilityCoverageAreaRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CapabilityCoverageAreaRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CapabilityCoverageAreaRequestMt> for CapabilityCoverageAreaRequest {
	fn as_ref(&self) -> &crate::v2_5::types::CapabilityCoverageAreaRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CapabilityCoverageAreaRequestMt> for CapabilityCoverageAreaRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CapabilityCoverageAreaRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CapabilityCoverageAreaRequestMt> for CapabilityCoverageAreaRequest {
	fn from(p: crate::v2_5::types::CapabilityCoverageAreaRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CapabilityCoverageAreaRequestMt> for CapabilityCoverageAreaRequest {
	fn into(self) -> crate::v2_5::types::CapabilityCoverageAreaRequestMt {
		self.0
	}
}


#[doc = r#"This message contains response information associated with a CapabilityCoverageAreaRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CapabilityCoverageAreaRequestStatus(
	pub crate::v2_5::types::CapabilityCoverageAreaRequestStatusMt,
);
impl Deref for CapabilityCoverageAreaRequestStatus {
	type Target = crate::v2_5::types::CapabilityCoverageAreaRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CapabilityCoverageAreaRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CapabilityCoverageAreaRequestStatusMt> for CapabilityCoverageAreaRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CapabilityCoverageAreaRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CapabilityCoverageAreaRequestStatusMt> for CapabilityCoverageAreaRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CapabilityCoverageAreaRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CapabilityCoverageAreaRequestStatusMt> for CapabilityCoverageAreaRequestStatus {
	fn from(p: crate::v2_5::types::CapabilityCoverageAreaRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CapabilityCoverageAreaRequestStatusMt> for CapabilityCoverageAreaRequestStatus {
	fn into(self) -> crate::v2_5::types::CapabilityCoverageAreaRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is the cargo delivery form of the general UCI Capability concept.  This message "advertises" the mostly static characteristics of a mission-ready cargo delivery Capability so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CargoDeliveryCapability(
	pub crate::v2_5::types::CargoDeliveryCapabilityMt,
);
impl Deref for CargoDeliveryCapability {
	type Target = crate::v2_5::types::CargoDeliveryCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CargoDeliveryCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CargoDeliveryCapabilityMt> for CargoDeliveryCapability {
	fn as_ref(&self) -> &crate::v2_5::types::CargoDeliveryCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CargoDeliveryCapabilityMt> for CargoDeliveryCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CargoDeliveryCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CargoDeliveryCapabilityMt> for CargoDeliveryCapability {
	fn from(p: crate::v2_5::types::CargoDeliveryCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CargoDeliveryCapabilityMt> for CargoDeliveryCapability {
	fn into(self) -> crate::v2_5::types::CargoDeliveryCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Cargo Delivery capabilities available to the system.   This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, vehicle flight profiles, etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CargoDeliveryCapabilityStatus(
	pub crate::v2_5::types::CargoDeliveryCapabilityStatusMt,
);
impl Deref for CargoDeliveryCapabilityStatus {
	type Target = crate::v2_5::types::CargoDeliveryCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CargoDeliveryCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CargoDeliveryCapabilityStatusMt> for CargoDeliveryCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CargoDeliveryCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CargoDeliveryCapabilityStatusMt> for CargoDeliveryCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CargoDeliveryCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CargoDeliveryCapabilityStatusMt> for CargoDeliveryCapabilityStatus {
	fn from(p: crate::v2_5::types::CargoDeliveryCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CargoDeliveryCapabilityStatusMt> for CargoDeliveryCapabilityStatus {
	fn into(self) -> crate::v2_5::types::CargoDeliveryCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the location and physical characteristics of a cargo item.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CargoStatus(
	pub crate::v2_5::types::CargoStatusMt,
);
impl Deref for CargoStatus {
	type Target = crate::v2_5::types::CargoStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CargoStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CargoStatusMt> for CargoStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CargoStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CargoStatusMt> for CargoStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CargoStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CargoStatusMt> for CargoStatus {
	fn from(p: crate::v2_5::types::CargoStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CargoStatusMt> for CargoStatus {
	fn into(self) -> crate::v2_5::types::CargoStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the COMINT Capability of a Subsystem of a System.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComintActivity(
	pub crate::v2_5::types::ComintActivityMt,
);
impl Deref for ComintActivity {
	type Target = crate::v2_5::types::ComintActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComintActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComintActivityMt> for ComintActivity {
	fn as_ref(&self) -> &crate::v2_5::types::ComintActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComintActivityMt> for ComintActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComintActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComintActivityMt> for ComintActivity {
	fn from(p: crate::v2_5::types::ComintActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComintActivityMt> for ComintActivity {
	fn into(self) -> crate::v2_5::types::ComintActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the COMINT category of UCI Capability, and includes both COMINT and ELINT functions.  This message "advertises" the mostly static characteristics of a mission-ready Capability (of a Subsystem of System) so that it can be "discovered" and used.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComintCapability(
	pub crate::v2_5::types::ComintCapabilityMt,
);
impl Deref for ComintCapability {
	type Target = crate::v2_5::types::ComintCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComintCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComintCapabilityMt> for ComintCapability {
	fn as_ref(&self) -> &crate::v2_5::types::ComintCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComintCapabilityMt> for ComintCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComintCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComintCapabilityMt> for ComintCapability {
	fn from(p: crate::v2_5::types::ComintCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComintCapabilityMt> for ComintCapability {
	fn into(self) -> crate::v2_5::types::ComintCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the COMINT capabilities available to the system as advertised in the COMINT_Capability message.  This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComintCapabilityStatus(
	pub crate::v2_5::types::ComintCapabilityStatusMt,
);
impl Deref for ComintCapabilityStatus {
	type Target = crate::v2_5::types::ComintCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComintCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComintCapabilityStatusMt> for ComintCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ComintCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComintCapabilityStatusMt> for ComintCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComintCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComintCapabilityStatusMt> for ComintCapabilityStatus {
	fn from(p: crate::v2_5::types::ComintCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComintCapabilityStatusMt> for ComintCapabilityStatus {
	fn into(self) -> crate::v2_5::types::ComintCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the COMINT form of the general UCI Capability Command.  It is used to manually invoke a COMINT Capability to perform a new COMINT Activity or change an existing interactive Activity.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComintCommand(
	pub crate::v2_5::types::ComintCommandMt,
);
impl Deref for ComintCommand {
	type Target = crate::v2_5::types::ComintCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComintCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComintCommandMt> for ComintCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ComintCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComintCommandMt> for ComintCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComintCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComintCommandMt> for ComintCommand {
	fn from(p: crate::v2_5::types::ComintCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComintCommandMt> for ComintCommand {
	fn into(self) -> crate::v2_5::types::ComintCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of a Command.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the Activity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComintCommandStatus(
	pub crate::v2_5::types::ComintCommandStatusMt,
);
impl Deref for ComintCommandStatus {
	type Target = crate::v2_5::types::ComintCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComintCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComintCommandStatusMt> for ComintCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ComintCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComintCommandStatusMt> for ComintCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComintCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComintCommandStatusMt> for ComintCommandStatus {
	fn from(p: crate::v2_5::types::ComintCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComintCommandStatusMt> for ComintCommandStatus {
	fn into(self) -> crate::v2_5::types::ComintCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to request consent to perform a function.  Status for this command message is provided via the ConsentRequestStatus message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComintConsentRequest(
	pub crate::v2_5::types::ComintConsentRequestMt,
);
impl Deref for ComintConsentRequest {
	type Target = crate::v2_5::types::ComintConsentRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComintConsentRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComintConsentRequestMt> for ComintConsentRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ComintConsentRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComintConsentRequestMt> for ComintConsentRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComintConsentRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComintConsentRequestMt> for ComintConsentRequest {
	fn from(p: crate::v2_5::types::ComintConsentRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComintConsentRequestMt> for ComintConsentRequest {
	fn into(self) -> crate::v2_5::types::ComintConsentRequestMt {
		self.0
	}
}


#[doc = r#"This message is used to report consent request status for its corresponding ConsentRequest message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComintConsentRequestStatus(
	pub crate::v2_5::types::ComintConsentRequestStatusMt,
);
impl Deref for ComintConsentRequestStatus {
	type Target = crate::v2_5::types::ComintConsentRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComintConsentRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComintConsentRequestStatusMt> for ComintConsentRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ComintConsentRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComintConsentRequestStatusMt> for ComintConsentRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComintConsentRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComintConsentRequestStatusMt> for ComintConsentRequestStatus {
	fn from(p: crate::v2_5::types::ComintConsentRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComintConsentRequestStatusMt> for ComintConsentRequestStatus {
	fn into(self) -> crate::v2_5::types::ComintConsentRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComintSettingsCommand(
	pub crate::v2_5::types::ComintSettingsCommandMt,
);
impl Deref for ComintSettingsCommand {
	type Target = crate::v2_5::types::ComintSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComintSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComintSettingsCommandMt> for ComintSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ComintSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComintSettingsCommandMt> for ComintSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComintSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComintSettingsCommandMt> for ComintSettingsCommand {
	fn from(p: crate::v2_5::types::ComintSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComintSettingsCommandMt> for ComintSettingsCommand {
	fn into(self) -> crate::v2_5::types::ComintSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message is used to report settings status for its corresponding SettingsCommand message used to change the settings associated with known capabilities.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComintSettingsCommandStatus(
	pub crate::v2_5::types::ComintSettingsCommandStatusMt,
);
impl Deref for ComintSettingsCommandStatus {
	type Target = crate::v2_5::types::ComintSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComintSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComintSettingsCommandStatusMt> for ComintSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ComintSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComintSettingsCommandStatusMt> for ComintSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComintSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComintSettingsCommandStatusMt> for ComintSettingsCommandStatus {
	fn from(p: crate::v2_5::types::ComintSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComintSettingsCommandStatusMt> for ComintSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::ComintSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message represents a pointing vector solution used in pointing communication antenna/beam; it indicates proposed pointing/coverage footprint of a communication system in order to satisfy an upcoming CommRequirement constrained by a previous CommScheduleAllocation.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommPointing(
	pub crate::v2_5::types::CommPointingMt,
);
impl Deref for CommPointing {
	type Target = crate::v2_5::types::CommPointingMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommPointing {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommPointingMt> for CommPointing {
	fn as_ref(&self) -> &crate::v2_5::types::CommPointingMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommPointingMt> for CommPointing {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommPointingMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommPointingMt> for CommPointing {
	fn from(p: crate::v2_5::types::CommPointingMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommPointingMt> for CommPointing {
	fn into(self) -> crate::v2_5::types::CommPointingMt {
		self.0
	}
}


#[doc = r#"This message specifies a C2 Requirement in the form/abstraction of CommSupport. Other C2 Requirement forms include Action, Effect, Task, [Capability]Command and  Response. CommSupport provides the means by which one or more communication resources can be scheduled for, allocated to, or utilized by one or more battlespace actors to accommodate their C2 requirements. For example an actor may need to plan or coordinate the use of one or more communication resources to execute an Action. See the child CommSupportType element for the CommSupport taxonomy. CommSupport can be planned (*Plan messages), directly commanded (CommSupportCommand* messages) and/or event-driven responses (Response* messages).UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupport(
	pub crate::v2_5::types::CommSupportMt,
);
impl Deref for CommSupport {
	type Target = crate::v2_5::types::CommSupportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportMt> for CommSupport {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportMt> for CommSupport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportMt> for CommSupport {
	fn from(p: crate::v2_5::types::CommSupportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportMt> for CommSupport {
	fn into(self) -> crate::v2_5::types::CommSupportMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the CommSupport Capability of a Subsystem of a System.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportActivity(
	pub crate::v2_5::types::CommSupportActivityMt,
);
impl Deref for CommSupportActivity {
	type Target = crate::v2_5::types::CommSupportActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportActivityMt> for CommSupportActivity {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportActivityMt> for CommSupportActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportActivityMt> for CommSupportActivity {
	fn from(p: crate::v2_5::types::CommSupportActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportActivityMt> for CommSupportActivity {
	fn into(self) -> crate::v2_5::types::CommSupportActivityMt {
		self.0
	}
}


#[doc = r#"This message is a request to cancel CommSupport which has been allocated and planned.  A planning input such as Effect, CommSupport, Task and DMPI can't easily be canceled or removed from the System due to race conditions between their various users and publishers, inevitability of the associated activity, etc.  Additionally, the operator or service initiating the cancellation might be different than the one that manages RequirementSets and/or issues *PlanCommand, introducing additional race conditions.  In order to avoid race conditions, receive positive feedback on the success of the cancellation and allow canceled messages/objects to remain in the system for historical purposes, an explicit CommSupportCancelCommand is necessary.  A CommSupportCancelCommand shall result in the CommSupport being canceled unless execution was already inevitable.  If the CommSupport was inevitable and started executing but can be stopped (such as a long collection CommSupport) it shall cancel as soon as possible.  CommSupportCancelCommand shall result in managers of RequirementSets to remove the associated CommSupport, thereby removing the CommSupport from the next planning cycle.  Services other than those that manage RequirementSets and execute activities aren't required to handle CommSupportCancelCommand.  CommSupportCancelCommand doesn't necessarily trigger a replan (there isn't a corresponding planning trigger), therefore a System could continue to navigate routes related to the canceled CommSupport, even though the CommSupport won't occur.  A subsequent replan could exclude the CommSupport.  Status or feedback for this message is given through CommSupportCancelCommandStatus but the resulting status of the CommSupport is given through CommSupportStatus.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportCancelCommand(
	pub crate::v2_5::types::CommSupportCancelCommandMt,
);
impl Deref for CommSupportCancelCommand {
	type Target = crate::v2_5::types::CommSupportCancelCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportCancelCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportCancelCommandMt> for CommSupportCancelCommand {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportCancelCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportCancelCommandMt> for CommSupportCancelCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportCancelCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportCancelCommandMt> for CommSupportCancelCommand {
	fn from(p: crate::v2_5::types::CommSupportCancelCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportCancelCommandMt> for CommSupportCancelCommand {
	fn into(self) -> crate::v2_5::types::CommSupportCancelCommandMt {
		self.0
	}
}


#[doc = r#"This message is sent in response to CommSupportCancelCommand and indicates if the CommSupport was canceled and if not why it was not canceled.  The resulting status of the CommSupport is reported in CommSupportStatus.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportCancelCommandStatus(
	pub crate::v2_5::types::CommSupportCancelCommandStatusMt,
);
impl Deref for CommSupportCancelCommandStatus {
	type Target = crate::v2_5::types::CommSupportCancelCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportCancelCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportCancelCommandStatusMt> for CommSupportCancelCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportCancelCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportCancelCommandStatusMt> for CommSupportCancelCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportCancelCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportCancelCommandStatusMt> for CommSupportCancelCommandStatus {
	fn from(p: crate::v2_5::types::CommSupportCancelCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportCancelCommandStatusMt> for CommSupportCancelCommandStatus {
	fn into(self) -> crate::v2_5::types::CommSupportCancelCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message represents the communications support or "CommSupport" category of UCI Capability.  A UCI System with a UCI CommSupportCapability provides communications resources for use by others.  For example, an orbital communications satellite and an airborne communications relay terminal would be considered UCI CommsSupport capabilities.  A UCI System that uses communications resources of providers can also have a UCI CommSupportCapability.  Representing both sides of the "link" with a CommSupportCapability enables full, symmetric machine-to-machine awareness of users and providers.  Users and providers might additionally have UCI CommTerminalCapability or GatewayCapability associated with their CommSupportCapability to facilitate detailed control of the operation of their communications subsystem(s).  The UCI CommsSupport Capability supports communication systems that require scheduling, bandwidth allocation, planning, dynamic pointing and other C2 coordination between providers and users.  Communications systems that don't require C2 coordination with users wouldn't necessarily need to use the CommSupportCapability.  This message "advertises" the mostly static characteristics of a mission-ready CommSupport Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportCapability(
	pub crate::v2_5::types::CommSupportCapabilityMt,
);
impl Deref for CommSupportCapability {
	type Target = crate::v2_5::types::CommSupportCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportCapabilityMt> for CommSupportCapability {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportCapabilityMt> for CommSupportCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportCapabilityMt> for CommSupportCapability {
	fn from(p: crate::v2_5::types::CommSupportCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportCapabilityMt> for CommSupportCapability {
	fn into(self) -> crate::v2_5::types::CommSupportCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the CommSupport capabilities available to the system.   This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportCapabilityStatus(
	pub crate::v2_5::types::CommSupportCapabilityStatusMt,
);
impl Deref for CommSupportCapabilityStatus {
	type Target = crate::v2_5::types::CommSupportCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportCapabilityStatusMt> for CommSupportCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportCapabilityStatusMt> for CommSupportCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportCapabilityStatusMt> for CommSupportCapabilityStatus {
	fn from(p: crate::v2_5::types::CommSupportCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportCapabilityStatusMt> for CommSupportCapabilityStatus {
	fn into(self) -> crate::v2_5::types::CommSupportCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the CommSupport form of the general UCI Capability Command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportCommand(
	pub crate::v2_5::types::CommSupportCommandMt,
);
impl Deref for CommSupportCommand {
	type Target = crate::v2_5::types::CommSupportCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportCommandMt> for CommSupportCommand {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportCommandMt> for CommSupportCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportCommandMt> for CommSupportCommand {
	fn from(p: crate::v2_5::types::CommSupportCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportCommandMt> for CommSupportCommand {
	fn into(self) -> crate::v2_5::types::CommSupportCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of CommSupportCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportCommandStatus(
	pub crate::v2_5::types::CommSupportCommandStatusMt,
);
impl Deref for CommSupportCommandStatus {
	type Target = crate::v2_5::types::CommSupportCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportCommandStatusMt> for CommSupportCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportCommandStatusMt> for CommSupportCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportCommandStatusMt> for CommSupportCommandStatus {
	fn from(p: crate::v2_5::types::CommSupportCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportCommandStatusMt> for CommSupportCommandStatus {
	fn into(self) -> crate::v2_5::types::CommSupportCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the state of approval for execution of communications support. ApprovalPolicy allow an authority to define policies to approve or reject a CommSupport as it enters execution. Approval may or may not be required. If approval is required, there can be multiple approvers. See Approval* messages for additional details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportExecutionApprovalStatus(
	pub crate::v2_5::types::CommSupportExecutionApprovalStatusMt,
);
impl Deref for CommSupportExecutionApprovalStatus {
	type Target = crate::v2_5::types::CommSupportExecutionApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportExecutionApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportExecutionApprovalStatusMt> for CommSupportExecutionApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportExecutionApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportExecutionApprovalStatusMt> for CommSupportExecutionApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportExecutionApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportExecutionApprovalStatusMt> for CommSupportExecutionApprovalStatus {
	fn from(p: crate::v2_5::types::CommSupportExecutionApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportExecutionApprovalStatusMt> for CommSupportExecutionApprovalStatus {
	fn into(self) -> crate::v2_5::types::CommSupportExecutionApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies the communications support ("comm support") associated with a System.  Details of comm support are described in the associated CommSupport message; the CommSupportPlan bundles CommSupport messages into sets associated with a System.  A CommSupportPlan can be developed manually by operators, by a plannin service or a combination.  This message decouples comm support from kinematic, task, action and other types of planning; comm support can be developed, updated and approved independent of other *Plans.  It enables any type of *Plan to be a constraint on comm support and vice-versa.

A CommSupportPlan can be an input and/or output of planning processes.  For example the CommSupportPlan for the top System in a hierarchical System of System could be an input to a comms planning service that then produces a CommSupportPlan per subordinate System with their subset of allocated comms support.

Additional details such as timing, dependencies, decomposition, etc. can be added during the comm support planning process and captured in the CommSupportPlan to supplement the information in the associated CommSupport messages themselves.

A CommSupportPlan can be created discretely or as part of a MissionPlan that includes other *Plans.  A CommSupportPlan can only be activated and executed as part of a MissionPlan.  A MissionPlan can be used to plan the execution order of multiple CommSupportPlans and *Plans in general.  A CommSupportPlan can be subject to approval per Approval* messages.  Planning, approval, activation and execution state information for a CommSupportPlan are given in other CommSupportPlan* messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportPlan(
	pub crate::v2_5::types::CommSupportPlanMt,
);
impl Deref for CommSupportPlan {
	type Target = crate::v2_5::types::CommSupportPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportPlanMt> for CommSupportPlan {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportPlanMt> for CommSupportPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportPlanMt> for CommSupportPlan {
	fn from(p: crate::v2_5::types::CommSupportPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportPlanMt> for CommSupportPlan {
	fn into(self) -> crate::v2_5::types::CommSupportPlanMt {
		self.0
	}
}


#[doc = r#"This message indicates status/state of approval for CommSupportPlan.  Approval may or may not be required.  ApprovalPolicy aligned with the *Plans and states of planning allow a planning oversight authority to approve or reject plans as they're created or updated.  Approval may or may not be required.  If required, there may be many approvers.  See Approval* messages for additional details.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportPlanApprovalStatus(
	pub crate::v2_5::types::CommSupportPlanApprovalStatusMt,
);
impl Deref for CommSupportPlanApprovalStatus {
	type Target = crate::v2_5::types::CommSupportPlanApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportPlanApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportPlanApprovalStatusMt> for CommSupportPlanApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportPlanApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportPlanApprovalStatusMt> for CommSupportPlanApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportPlanApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportPlanApprovalStatusMt> for CommSupportPlanApprovalStatus {
	fn from(p: crate::v2_5::types::CommSupportPlanApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportPlanApprovalStatusMt> for CommSupportPlanApprovalStatus {
	fn into(self) -> crate::v2_5::types::CommSupportPlanApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message invokes CommSupportPlan planning process.  Each planning process is declared with a unique ID in the ControlStatus message; that ID is used in this message to invoke the process.  This message includes many inputs to the planning process but many others may come from a variety of other messages.  A few examples of the many inputs include:
1. Options for constraining the planning function in a variety of ways using existing Plans of the same type or by other Plan types.  For example, CommSupportPlan could be constrained by a previous RoutePlan, a previous RouteActivityPlan and/or a TaskPlan.
2. Environment overrides to selectively modify details of the current planning environment in the context of a single planning command. For example, a known threat Entity in the environment could be removed and an expected Entity could be added to the environment in the context of a single planning command in support of "what-if" planning.
3. "Weightings" that influence the decisions of operators or planning algorithms performing the planning.
4. Temporal and/or kinematic begin and end points.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportPlanCommand(
	pub crate::v2_5::types::CommSupportPlanCommandMt,
);
impl Deref for CommSupportPlanCommand {
	type Target = crate::v2_5::types::CommSupportPlanCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportPlanCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportPlanCommandMt> for CommSupportPlanCommand {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportPlanCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportPlanCommandMt> for CommSupportPlanCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportPlanCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportPlanCommandMt> for CommSupportPlanCommand {
	fn from(p: crate::v2_5::types::CommSupportPlanCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportPlanCommandMt> for CommSupportPlanCommand {
	fn into(self) -> crate::v2_5::types::CommSupportPlanCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to create/update CommSupportPlan, including the current state in a command and processing state machine; see the CommSupportPlanCommand message.  Creation/update of CommSupportPlan  may occur autonomously, without CommSupportPlanCommand in which case the current state of the plan could be given in the CommSupportPlanStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportPlanCommandStatus(
	pub crate::v2_5::types::CommSupportPlanCommandStatusMt,
);
impl Deref for CommSupportPlanCommandStatus {
	type Target = crate::v2_5::types::CommSupportPlanCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportPlanCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportPlanCommandStatusMt> for CommSupportPlanCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportPlanCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportPlanCommandStatusMt> for CommSupportPlanCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportPlanCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportPlanCommandStatusMt> for CommSupportPlanCommandStatus {
	fn from(p: crate::v2_5::types::CommSupportPlanCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportPlanCommandStatusMt> for CommSupportPlanCommandStatus {
	fn into(self) -> crate::v2_5::types::CommSupportPlanCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the execution status for one or more CommSupportPlans.  Plan execution begins after successful autonomous plan activation or activation via CommSupportPlanActivation messages.  This message provides execution status regardless of how execution was initiated.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportPlanExecutionStatus(
	pub crate::v2_5::types::CommSupportPlanExecutionStatusMt,
);
impl Deref for CommSupportPlanExecutionStatus {
	type Target = crate::v2_5::types::CommSupportPlanExecutionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportPlanExecutionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportPlanExecutionStatusMt> for CommSupportPlanExecutionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportPlanExecutionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportPlanExecutionStatusMt> for CommSupportPlanExecutionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportPlanExecutionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportPlanExecutionStatusMt> for CommSupportPlanExecutionStatus {
	fn from(p: crate::v2_5::types::CommSupportPlanExecutionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportPlanExecutionStatusMt> for CommSupportPlanExecutionStatus {
	fn into(self) -> crate::v2_5::types::CommSupportPlanExecutionStatusMt {
		self.0
	}
}


#[doc = r#"This message provides status for CommSupportPlan.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportPlanStatus(
	pub crate::v2_5::types::CommSupportPlanStatusMt,
);
impl Deref for CommSupportPlanStatus {
	type Target = crate::v2_5::types::CommSupportPlanStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportPlanStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportPlanStatusMt> for CommSupportPlanStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportPlanStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportPlanStatusMt> for CommSupportPlanStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportPlanStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportPlanStatusMt> for CommSupportPlanStatus {
	fn from(p: crate::v2_5::types::CommSupportPlanStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportPlanStatusMt> for CommSupportPlanStatus {
	fn into(self) -> crate::v2_5::types::CommSupportPlanStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the validation, including the current state in a validation state machine and details of any invalid items. This validation can be published periodically or be event-driven. Refer to the CommmandSupportPlanValidationCommand for details.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportPlanValidation(
	pub crate::v2_5::types::CommSupportPlanValidationMt,
);
impl Deref for CommSupportPlanValidation {
	type Target = crate::v2_5::types::CommSupportPlanValidationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportPlanValidation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportPlanValidationMt> for CommSupportPlanValidation {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportPlanValidationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportPlanValidationMt> for CommSupportPlanValidation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportPlanValidationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportPlanValidationMt> for CommSupportPlanValidation {
	fn from(p: crate::v2_5::types::CommSupportPlanValidationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportPlanValidationMt> for CommSupportPlanValidation {
	fn into(self) -> crate::v2_5::types::CommSupportPlanValidationMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to validate/re-validate an existing CommSupportPlan.  The variables a given planning service, operator or system considers when validating a plan can vary.  Examples include weather, order of battle changes, kinematic movement constraints, operator manual edits and many other reasons.  The message allows an existing CommSupportPlan to be checked for validity given such changes.  The variables a given planning service, operator or system considers when validating a plan can vary.  Different variables might be considered depending on the level of detail of the plan or stage in the overall planning process.  The scope and meaning of "valid" is defined by the services, operator(s) and systems creating and validating the plan.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportPlanValidationCommand(
	pub crate::v2_5::types::CommSupportPlanValidationCommandMt,
);
impl Deref for CommSupportPlanValidationCommand {
	type Target = crate::v2_5::types::CommSupportPlanValidationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportPlanValidationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportPlanValidationCommandMt> for CommSupportPlanValidationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportPlanValidationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportPlanValidationCommandMt> for CommSupportPlanValidationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportPlanValidationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportPlanValidationCommandMt> for CommSupportPlanValidationCommand {
	fn from(p: crate::v2_5::types::CommSupportPlanValidationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportPlanValidationCommandMt> for CommSupportPlanValidationCommand {
	fn into(self) -> crate::v2_5::types::CommSupportPlanValidationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to validate CommSupportPlan, including the current state in a command and processing state machine.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportPlanValidationCommandStatus(
	pub crate::v2_5::types::CommSupportPlanValidationCommandStatusMt,
);
impl Deref for CommSupportPlanValidationCommandStatus {
	type Target = crate::v2_5::types::CommSupportPlanValidationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportPlanValidationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportPlanValidationCommandStatusMt> for CommSupportPlanValidationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportPlanValidationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportPlanValidationCommandStatusMt> for CommSupportPlanValidationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportPlanValidationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportPlanValidationCommandStatusMt> for CommSupportPlanValidationCommandStatus {
	fn from(p: crate::v2_5::types::CommSupportPlanValidationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportPlanValidationCommandStatusMt> for CommSupportPlanValidationCommandStatus {
	fn into(self) -> crate::v2_5::types::CommSupportPlanValidationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message defines planning status of a single CommSupport.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportPlanningStatus(
	pub crate::v2_5::types::CommSupportPlanningStatusMt,
);
impl Deref for CommSupportPlanningStatus {
	type Target = crate::v2_5::types::CommSupportPlanningStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportPlanningStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportPlanningStatusMt> for CommSupportPlanningStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportPlanningStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportPlanningStatusMt> for CommSupportPlanningStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportPlanningStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportPlanningStatusMt> for CommSupportPlanningStatus {
	fn from(p: crate::v2_5::types::CommSupportPlanningStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportPlanningStatusMt> for CommSupportPlanningStatus {
	fn into(self) -> crate::v2_5::types::CommSupportPlanningStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the settings associated with CommSupport Capabilities of a Subsystem.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportSettingsCommand(
	pub crate::v2_5::types::CommSupportSettingsCommandMt,
);
impl Deref for CommSupportSettingsCommand {
	type Target = crate::v2_5::types::CommSupportSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportSettingsCommandMt> for CommSupportSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportSettingsCommandMt> for CommSupportSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportSettingsCommandMt> for CommSupportSettingsCommand {
	fn from(p: crate::v2_5::types::CommSupportSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportSettingsCommandMt> for CommSupportSettingsCommand {
	fn into(self) -> crate::v2_5::types::CommSupportSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message reports the acknowledgment and/or acceptance of a CommSupportSettingsCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportSettingsCommandStatus(
	pub crate::v2_5::types::CommSupportSettingsCommandStatusMt,
);
impl Deref for CommSupportSettingsCommandStatus {
	type Target = crate::v2_5::types::CommSupportSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportSettingsCommandStatusMt> for CommSupportSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportSettingsCommandStatusMt> for CommSupportSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportSettingsCommandStatusMt> for CommSupportSettingsCommandStatus {
	fn from(p: crate::v2_5::types::CommSupportSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportSettingsCommandStatusMt> for CommSupportSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::CommSupportSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"Indicates the execution status for CommSupport.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommSupportStatus(
	pub crate::v2_5::types::CommSupportStatusMt,
);
impl Deref for CommSupportStatus {
	type Target = crate::v2_5::types::CommSupportStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommSupportStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommSupportStatusMt> for CommSupportStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommSupportStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommSupportStatusMt> for CommSupportStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommSupportStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommSupportStatusMt> for CommSupportStatus {
	fn from(p: crate::v2_5::types::CommSupportStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommSupportStatusMt> for CommSupportStatus {
	fn into(self) -> crate::v2_5::types::CommSupportStatusMt {
		self.0
	}
}


#[doc = r#"A CommTerminalActivity message describes what a communication terminal is doing.   This message indicates the combined in-work and to-do list of the CommTerminalCapability of a Subsystem.  In UCI terminology, an Activity is the dynamic, per-use status of a Capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalActivity(
	pub crate::v2_5::types::CommTerminalActivityMt,
);
impl Deref for CommTerminalActivity {
	type Target = crate::v2_5::types::CommTerminalActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalActivityMt> for CommTerminalActivity {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalActivityMt> for CommTerminalActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalActivityMt> for CommTerminalActivity {
	fn from(p: crate::v2_5::types::CommTerminalActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalActivityMt> for CommTerminalActivity {
	fn into(self) -> crate::v2_5::types::CommTerminalActivityMt {
		self.0
	}
}


#[doc = r#"A CommTerminalCapability message describes what a communications subsystem is capable of doing if invoked.  The capabilities include waveform instantiation/tear-down and waveform, user I/O, crypto, etc. settings provided by the communications subsystem.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalCapability(
	pub crate::v2_5::types::CommTerminalCapabilityMt,
);
impl Deref for CommTerminalCapability {
	type Target = crate::v2_5::types::CommTerminalCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalCapabilityMt> for CommTerminalCapability {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalCapabilityMt> for CommTerminalCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalCapabilityMt> for CommTerminalCapability {
	fn from(p: crate::v2_5::types::CommTerminalCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalCapabilityMt> for CommTerminalCapability {
	fn into(self) -> crate::v2_5::types::CommTerminalCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the CommTerminal capabilities available to the system. This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, associated Waveform profiles etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalCapabilityStatus(
	pub crate::v2_5::types::CommTerminalCapabilityStatusMt,
);
impl Deref for CommTerminalCapabilityStatus {
	type Target = crate::v2_5::types::CommTerminalCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalCapabilityStatusMt> for CommTerminalCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalCapabilityStatusMt> for CommTerminalCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalCapabilityStatusMt> for CommTerminalCapabilityStatus {
	fn from(p: crate::v2_5::types::CommTerminalCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalCapabilityStatusMt> for CommTerminalCapabilityStatus {
	fn into(self) -> crate::v2_5::types::CommTerminalCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is a derivation of the UCI Capability Command.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and Waveform Commands including Capability precedence, Task rank, Waveform Command rank, Waveform Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalCommand(
	pub crate::v2_5::types::CommTerminalCommandMt,
);
impl Deref for CommTerminalCommand {
	type Target = crate::v2_5::types::CommTerminalCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalCommandMt> for CommTerminalCommand {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalCommandMt> for CommTerminalCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalCommandMt> for CommTerminalCommand {
	fn from(p: crate::v2_5::types::CommTerminalCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalCommandMt> for CommTerminalCommand {
	fn into(self) -> crate::v2_5::types::CommTerminalCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of a CommTerminalCommand.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the CommTerminalActivity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalCommandStatus(
	pub crate::v2_5::types::CommTerminalCommandStatusMt,
);
impl Deref for CommTerminalCommandStatus {
	type Target = crate::v2_5::types::CommTerminalCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalCommandStatusMt> for CommTerminalCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalCommandStatusMt> for CommTerminalCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalCommandStatusMt> for CommTerminalCommandStatus {
	fn from(p: crate::v2_5::types::CommTerminalCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalCommandStatusMt> for CommTerminalCommandStatus {
	fn into(self) -> crate::v2_5::types::CommTerminalCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies the CommTerminalPlan that will be performed by a communications subsystem or hierarchical family of communications subsystems during its mission.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalPlan(
	pub crate::v2_5::types::CommTerminalPlanMt,
);
impl Deref for CommTerminalPlan {
	type Target = crate::v2_5::types::CommTerminalPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalPlanMt> for CommTerminalPlan {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalPlanMt> for CommTerminalPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalPlanMt> for CommTerminalPlan {
	fn from(p: crate::v2_5::types::CommTerminalPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalPlanMt> for CommTerminalPlan {
	fn into(self) -> crate::v2_5::types::CommTerminalPlanMt {
		self.0
	}
}


#[doc = r#"This message provides the ability to command upload and activation of a CommTerminalPlan.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalPlanActivationCommand(
	pub crate::v2_5::types::CommTerminalPlanActivationCommandMt,
);
impl Deref for CommTerminalPlanActivationCommand {
	type Target = crate::v2_5::types::CommTerminalPlanActivationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalPlanActivationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalPlanActivationCommandMt> for CommTerminalPlanActivationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalPlanActivationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalPlanActivationCommandMt> for CommTerminalPlanActivationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalPlanActivationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalPlanActivationCommandMt> for CommTerminalPlanActivationCommand {
	fn from(p: crate::v2_5::types::CommTerminalPlanActivationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalPlanActivationCommandMt> for CommTerminalPlanActivationCommand {
	fn into(self) -> crate::v2_5::types::CommTerminalPlanActivationCommandMt {
		self.0
	}
}


#[doc = r#"This message is the response to a CommTerminalPlanActivationCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalPlanActivationCommandStatus(
	pub crate::v2_5::types::CommTerminalPlanActivationCommandStatusMt,
);
impl Deref for CommTerminalPlanActivationCommandStatus {
	type Target = crate::v2_5::types::CommTerminalPlanActivationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalPlanActivationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalPlanActivationCommandStatusMt> for CommTerminalPlanActivationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalPlanActivationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalPlanActivationCommandStatusMt> for CommTerminalPlanActivationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalPlanActivationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalPlanActivationCommandStatusMt> for CommTerminalPlanActivationCommandStatus {
	fn from(p: crate::v2_5::types::CommTerminalPlanActivationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalPlanActivationCommandStatusMt> for CommTerminalPlanActivationCommandStatus {
	fn into(self) -> crate::v2_5::types::CommTerminalPlanActivationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message provides status of a communications plan along the planning, conversion, upload, and activation chain.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalPlanActivationStatus(
	pub crate::v2_5::types::CommTerminalPlanActivationStatusMt,
);
impl Deref for CommTerminalPlanActivationStatus {
	type Target = crate::v2_5::types::CommTerminalPlanActivationStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalPlanActivationStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalPlanActivationStatusMt> for CommTerminalPlanActivationStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalPlanActivationStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalPlanActivationStatusMt> for CommTerminalPlanActivationStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalPlanActivationStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalPlanActivationStatusMt> for CommTerminalPlanActivationStatus {
	fn from(p: crate::v2_5::types::CommTerminalPlanActivationStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalPlanActivationStatusMt> for CommTerminalPlanActivationStatus {
	fn into(self) -> crate::v2_5::types::CommTerminalPlanActivationStatusMt {
		self.0
	}
}


#[doc = r#"This message provides an operator the ability to request the activation of pre-mission planned comm terminal settings, in coordination with, operator inputs.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalPlanOverrideRequest(
	pub crate::v2_5::types::CommTerminalPlanOverrideRequestMt,
);
impl Deref for CommTerminalPlanOverrideRequest {
	type Target = crate::v2_5::types::CommTerminalPlanOverrideRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalPlanOverrideRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalPlanOverrideRequestMt> for CommTerminalPlanOverrideRequest {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalPlanOverrideRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalPlanOverrideRequestMt> for CommTerminalPlanOverrideRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalPlanOverrideRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalPlanOverrideRequestMt> for CommTerminalPlanOverrideRequest {
	fn from(p: crate::v2_5::types::CommTerminalPlanOverrideRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalPlanOverrideRequestMt> for CommTerminalPlanOverrideRequest {
	fn into(self) -> crate::v2_5::types::CommTerminalPlanOverrideRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to a CommTerminalPlanOverrideRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalPlanOverrideRequestStatus(
	pub crate::v2_5::types::CommTerminalPlanOverrideRequestStatusMt,
);
impl Deref for CommTerminalPlanOverrideRequestStatus {
	type Target = crate::v2_5::types::CommTerminalPlanOverrideRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalPlanOverrideRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalPlanOverrideRequestStatusMt> for CommTerminalPlanOverrideRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalPlanOverrideRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalPlanOverrideRequestStatusMt> for CommTerminalPlanOverrideRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalPlanOverrideRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalPlanOverrideRequestStatusMt> for CommTerminalPlanOverrideRequestStatus {
	fn from(p: crate::v2_5::types::CommTerminalPlanOverrideRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalPlanOverrideRequestStatusMt> for CommTerminalPlanOverrideRequestStatus {
	fn into(self) -> crate::v2_5::types::CommTerminalPlanOverrideRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with Waveform Capabilities of a Subsystem.  Waveform SettingsCommands generally affect the subsequent operation of applicable Waveform Capabilities of the Subsystem; they are considered presettings, independent of Waveform Command.  Unlike most Waveform Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalSettingsCommand(
	pub crate::v2_5::types::CommTerminalSettingsCommandMt,
);
impl Deref for CommTerminalSettingsCommand {
	type Target = crate::v2_5::types::CommTerminalSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalSettingsCommandMt> for CommTerminalSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalSettingsCommandMt> for CommTerminalSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalSettingsCommandMt> for CommTerminalSettingsCommand {
	fn from(p: crate::v2_5::types::CommTerminalSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalSettingsCommandMt> for CommTerminalSettingsCommand {
	fn into(self) -> crate::v2_5::types::CommTerminalSettingsCommandMt {
		self.0
	}
}


#[doc = r#"Reports the acknowledgment and/or acceptance of a Waveform Settings command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommTerminalSettingsCommandStatus(
	pub crate::v2_5::types::CommTerminalSettingsCommandStatusMt,
);
impl Deref for CommTerminalSettingsCommandStatus {
	type Target = crate::v2_5::types::CommTerminalSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommTerminalSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommTerminalSettingsCommandStatusMt> for CommTerminalSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommTerminalSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommTerminalSettingsCommandStatusMt> for CommTerminalSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommTerminalSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommTerminalSettingsCommandStatusMt> for CommTerminalSettingsCommandStatus {
	fn from(p: crate::v2_5::types::CommTerminalSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommTerminalSettingsCommandStatusMt> for CommTerminalSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::CommTerminalSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the CommandedTimeline Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (CommandedTimelineCommand) from an Operator or Capability management Service, 3) currently in-work CommandedTimeline, 4) CommandedTimeline scheduled for the future and 5) CommandedTimeline that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single CommandedTimelineCommand or other triggering event can result in multiple activities within the CommandedTimelineActivity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommandedTimelineActivity(
	pub crate::v2_5::types::CommandedTimelineActivityMt,
);
impl Deref for CommandedTimelineActivity {
	type Target = crate::v2_5::types::CommandedTimelineActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommandedTimelineActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommandedTimelineActivityMt> for CommandedTimelineActivity {
	fn as_ref(&self) -> &crate::v2_5::types::CommandedTimelineActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommandedTimelineActivityMt> for CommandedTimelineActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommandedTimelineActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommandedTimelineActivityMt> for CommandedTimelineActivity {
	fn from(p: crate::v2_5::types::CommandedTimelineActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommandedTimelineActivityMt> for CommandedTimelineActivity {
	fn into(self) -> crate::v2_5::types::CommandedTimelineActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the Commanded Timeline category of UCI Capability.  Commanded Timeline supports coordinated opeartions.  This message "advertises" the mostly static characteristics of a mission-ready Commanded Timeline Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommandedTimelineCapability(
	pub crate::v2_5::types::CommandedTimelineCapabilityMt,
);
impl Deref for CommandedTimelineCapability {
	type Target = crate::v2_5::types::CommandedTimelineCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommandedTimelineCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommandedTimelineCapabilityMt> for CommandedTimelineCapability {
	fn as_ref(&self) -> &crate::v2_5::types::CommandedTimelineCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommandedTimelineCapabilityMt> for CommandedTimelineCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommandedTimelineCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommandedTimelineCapabilityMt> for CommandedTimelineCapability {
	fn from(p: crate::v2_5::types::CommandedTimelineCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommandedTimelineCapabilityMt> for CommandedTimelineCapability {
	fn into(self) -> crate::v2_5::types::CommandedTimelineCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Commanded Timeline capabilities available to the system.   This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc.  Since Commanded Timeline capabilities refer to both an active and/or passive capability, an EMCON restriction may result in the Commanded Timeline capabilities being temporarily unavailable.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommandedTimelineCapabilityStatus(
	pub crate::v2_5::types::CommandedTimelineCapabilityStatusMt,
);
impl Deref for CommandedTimelineCapabilityStatus {
	type Target = crate::v2_5::types::CommandedTimelineCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommandedTimelineCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommandedTimelineCapabilityStatusMt> for CommandedTimelineCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommandedTimelineCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommandedTimelineCapabilityStatusMt> for CommandedTimelineCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommandedTimelineCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommandedTimelineCapabilityStatusMt> for CommandedTimelineCapabilityStatus {
	fn from(p: crate::v2_5::types::CommandedTimelineCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommandedTimelineCapabilityStatusMt> for CommandedTimelineCapabilityStatus {
	fn into(self) -> crate::v2_5::types::CommandedTimelineCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the CommandedTimeline form of the general UCI Capability Command.  CommandedTimeline is a radar Capability that includes active transmission of RF signals.  It is used to manually invoke an CommandedTimeline Capability to perform a new CommandedTimeline Activity or to make a change to an existing interactive CommandedTimeline Activity.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommandedTimelineCommand(
	pub crate::v2_5::types::CommandedTimelineCommandMt,
);
impl Deref for CommandedTimelineCommand {
	type Target = crate::v2_5::types::CommandedTimelineCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommandedTimelineCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommandedTimelineCommandMt> for CommandedTimelineCommand {
	fn as_ref(&self) -> &crate::v2_5::types::CommandedTimelineCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommandedTimelineCommandMt> for CommandedTimelineCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommandedTimelineCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommandedTimelineCommandMt> for CommandedTimelineCommand {
	fn from(p: crate::v2_5::types::CommandedTimelineCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommandedTimelineCommandMt> for CommandedTimelineCommand {
	fn into(self) -> crate::v2_5::types::CommandedTimelineCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an CommandedTimelineCommand.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the CommandedTimelineActivity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommandedTimelineCommandStatus(
	pub crate::v2_5::types::CommandedTimelineCommandStatusMt,
);
impl Deref for CommandedTimelineCommandStatus {
	type Target = crate::v2_5::types::CommandedTimelineCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommandedTimelineCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommandedTimelineCommandStatusMt> for CommandedTimelineCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommandedTimelineCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommandedTimelineCommandStatusMt> for CommandedTimelineCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommandedTimelineCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommandedTimelineCommandStatusMt> for CommandedTimelineCommandStatus {
	fn from(p: crate::v2_5::types::CommandedTimelineCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommandedTimelineCommandStatusMt> for CommandedTimelineCommandStatus {
	fn into(self) -> crate::v2_5::types::CommandedTimelineCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the CommandedTimeline Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommandedTimelineSettingsCommand(
	pub crate::v2_5::types::CommandedTimelineSettingsCommandMt,
);
impl Deref for CommandedTimelineSettingsCommand {
	type Target = crate::v2_5::types::CommandedTimelineSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommandedTimelineSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommandedTimelineSettingsCommandMt> for CommandedTimelineSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::CommandedTimelineSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommandedTimelineSettingsCommandMt> for CommandedTimelineSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommandedTimelineSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommandedTimelineSettingsCommandMt> for CommandedTimelineSettingsCommand {
	fn from(p: crate::v2_5::types::CommandedTimelineSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommandedTimelineSettingsCommandMt> for CommandedTimelineSettingsCommand {
	fn into(self) -> crate::v2_5::types::CommandedTimelineSettingsCommandMt {
		self.0
	}
}


#[doc = r#"Reports the acknowledgment and/or acceptance of an CommandedTimeline settings command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CommandedTimelineSettingsCommandStatus(
	pub crate::v2_5::types::CommandedTimelineSettingsCommandStatusMt,
);
impl Deref for CommandedTimelineSettingsCommandStatus {
	type Target = crate::v2_5::types::CommandedTimelineSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CommandedTimelineSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CommandedTimelineSettingsCommandStatusMt> for CommandedTimelineSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CommandedTimelineSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CommandedTimelineSettingsCommandStatusMt> for CommandedTimelineSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CommandedTimelineSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CommandedTimelineSettingsCommandStatusMt> for CommandedTimelineSettingsCommandStatus {
	fn from(p: crate::v2_5::types::CommandedTimelineSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CommandedTimelineSettingsCommandStatusMt> for CommandedTimelineSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::CommandedTimelineSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message contains configuration information for a component.  The status of components is reported in the ComponentStatus and SubsystemStatus messages as applicable. This is typically static information.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComponentConfiguration(
	pub crate::v2_5::types::ComponentConfigurationMt,
);
impl Deref for ComponentConfiguration {
	type Target = crate::v2_5::types::ComponentConfigurationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComponentConfiguration {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComponentConfigurationMt> for ComponentConfiguration {
	fn as_ref(&self) -> &crate::v2_5::types::ComponentConfigurationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComponentConfigurationMt> for ComponentConfiguration {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComponentConfigurationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComponentConfigurationMt> for ComponentConfiguration {
	fn from(p: crate::v2_5::types::ComponentConfigurationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComponentConfigurationMt> for ComponentConfiguration {
	fn into(self) -> crate::v2_5::types::ComponentConfigurationMt {
		self.0
	}
}


#[doc = r#"This message is used to request configuration information for a component.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComponentConfigurationDataRequest(
	pub crate::v2_5::types::ComponentConfigurationDataRequestMt,
);
impl Deref for ComponentConfigurationDataRequest {
	type Target = crate::v2_5::types::ComponentConfigurationDataRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComponentConfigurationDataRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComponentConfigurationDataRequestMt> for ComponentConfigurationDataRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ComponentConfigurationDataRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComponentConfigurationDataRequestMt> for ComponentConfigurationDataRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComponentConfigurationDataRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComponentConfigurationDataRequestMt> for ComponentConfigurationDataRequest {
	fn from(p: crate::v2_5::types::ComponentConfigurationDataRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComponentConfigurationDataRequestMt> for ComponentConfigurationDataRequest {
	fn into(self) -> crate::v2_5::types::ComponentConfigurationDataRequestMt {
		self.0
	}
}


#[doc = r#"This contains the response to a ComponentConfigurationRequest message.  It contains configuration information for a component.  It can also represent a tree structure of subcomponents (and their configurations) that comprise the component.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComponentConfigurationDataRequestStatus(
	pub crate::v2_5::types::ComponentConfigurationDataRequestStatusMt,
);
impl Deref for ComponentConfigurationDataRequestStatus {
	type Target = crate::v2_5::types::ComponentConfigurationDataRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComponentConfigurationDataRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComponentConfigurationDataRequestStatusMt> for ComponentConfigurationDataRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ComponentConfigurationDataRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComponentConfigurationDataRequestStatusMt> for ComponentConfigurationDataRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComponentConfigurationDataRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComponentConfigurationDataRequestStatusMt> for ComponentConfigurationDataRequestStatus {
	fn from(p: crate::v2_5::types::ComponentConfigurationDataRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComponentConfigurationDataRequestStatusMt> for ComponentConfigurationDataRequestStatus {
	fn into(self) -> crate::v2_5::types::ComponentConfigurationDataRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message commands the component to update its settings.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComponentSettingsCommand(
	pub crate::v2_5::types::ComponentSettingsCommandMt,
);
impl Deref for ComponentSettingsCommand {
	type Target = crate::v2_5::types::ComponentSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComponentSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComponentSettingsCommandMt> for ComponentSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ComponentSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComponentSettingsCommandMt> for ComponentSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComponentSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComponentSettingsCommandMt> for ComponentSettingsCommand {
	fn from(p: crate::v2_5::types::ComponentSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComponentSettingsCommandMt> for ComponentSettingsCommand {
	fn into(self) -> crate::v2_5::types::ComponentSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This is a message sent back to a ComponentSettingsCommand for or on behalf of a Component.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComponentSettingsCommandStatus(
	pub crate::v2_5::types::ComponentSettingsCommandStatusMt,
);
impl Deref for ComponentSettingsCommandStatus {
	type Target = crate::v2_5::types::ComponentSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComponentSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComponentSettingsCommandStatusMt> for ComponentSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ComponentSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComponentSettingsCommandStatusMt> for ComponentSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComponentSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComponentSettingsCommandStatusMt> for ComponentSettingsCommandStatus {
	fn from(p: crate::v2_5::types::ComponentSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComponentSettingsCommandStatusMt> for ComponentSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::ComponentSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the current operating state of a component or list of components.  A component can be physical or functional and could be outside of a Subsystem.  Any component that is relevant to the state, health and/or C2 of a system can be reported. This message can also report status for items in a component such as electrical equipment or hydraulic equipment that are documented outside of UCI in an ICD or to report engine specific status information such as throttle.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComponentStatus(
	pub crate::v2_5::types::ComponentStatusMt,
);
impl Deref for ComponentStatus {
	type Target = crate::v2_5::types::ComponentStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComponentStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComponentStatusMt> for ComponentStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ComponentStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComponentStatusMt> for ComponentStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComponentStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComponentStatusMt> for ComponentStatus {
	fn from(p: crate::v2_5::types::ComponentStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComponentStatusMt> for ComponentStatus {
	fn into(self) -> crate::v2_5::types::ComponentStatusMt {
		self.0
	}
}


#[doc = r#"This message request a Component's current ComponentStatus.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComponentStatusDataRequest(
	pub crate::v2_5::types::ComponentStatusDataRequestMt,
);
impl Deref for ComponentStatusDataRequest {
	type Target = crate::v2_5::types::ComponentStatusDataRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComponentStatusDataRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComponentStatusDataRequestMt> for ComponentStatusDataRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ComponentStatusDataRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComponentStatusDataRequestMt> for ComponentStatusDataRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComponentStatusDataRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComponentStatusDataRequestMt> for ComponentStatusDataRequest {
	fn from(p: crate::v2_5::types::ComponentStatusDataRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComponentStatusDataRequestMt> for ComponentStatusDataRequest {
	fn into(self) -> crate::v2_5::types::ComponentStatusDataRequestMt {
		self.0
	}
}


#[doc = r#"This message contains the results of a ComponentStatusDataRequest.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ComponentStatusDataRequestStatus(
	pub crate::v2_5::types::ComponentStatusDataRequestStatusMt,
);
impl Deref for ComponentStatusDataRequestStatus {
	type Target = crate::v2_5::types::ComponentStatusDataRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ComponentStatusDataRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ComponentStatusDataRequestStatusMt> for ComponentStatusDataRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ComponentStatusDataRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ComponentStatusDataRequestStatusMt> for ComponentStatusDataRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ComponentStatusDataRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ComponentStatusDataRequestStatusMt> for ComponentStatusDataRequestStatus {
	fn from(p: crate::v2_5::types::ComponentStatusDataRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ComponentStatusDataRequestStatusMt> for ComponentStatusDataRequestStatus {
	fn into(self) -> crate::v2_5::types::ComponentStatusDataRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates a command from a controller to a controllee to establish or change its active/accepted control interfaces.  This message is only accepted/obeyed when it comes from the current controlling System (mission control) or the current primary controller (capability control).  A controllee reports its current active/accepted control interfaces via the ControlStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ControlInterfacesCommand(
	pub crate::v2_5::types::ControlInterfacesCommandMt,
);
impl Deref for ControlInterfacesCommand {
	type Target = crate::v2_5::types::ControlInterfacesCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ControlInterfacesCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ControlInterfacesCommandMt> for ControlInterfacesCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ControlInterfacesCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ControlInterfacesCommandMt> for ControlInterfacesCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ControlInterfacesCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ControlInterfacesCommandMt> for ControlInterfacesCommand {
	fn from(p: crate::v2_5::types::ControlInterfacesCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ControlInterfacesCommandMt> for ControlInterfacesCommand {
	fn into(self) -> crate::v2_5::types::ControlInterfacesCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status for a ControlInterfacesCommand message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ControlInterfacesCommandStatus(
	pub crate::v2_5::types::ControlInterfacesCommandStatusMt,
);
impl Deref for ControlInterfacesCommandStatus {
	type Target = crate::v2_5::types::ControlInterfacesCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ControlInterfacesCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ControlInterfacesCommandStatusMt> for ControlInterfacesCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ControlInterfacesCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ControlInterfacesCommandStatusMt> for ControlInterfacesCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ControlInterfacesCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ControlInterfacesCommandStatusMt> for ControlInterfacesCommandStatus {
	fn from(p: crate::v2_5::types::ControlInterfacesCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ControlInterfacesCommandStatusMt> for ControlInterfacesCommandStatus {
	fn into(self) -> crate::v2_5::types::ControlInterfacesCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message requests control of a UCI System or its Capabilities.  UCI Systems are collections of capabilities that can be pseudo-independently shared/controlled by multiple users.  Control of a UCI System or its Capabilities can be requested using this message.  The System/Service that currently has control (mission control) or is the primary controller (capability control) is responsible for responding to an "Acquire" request. The controlling System/Service can release control with a "Release" request. The Controllee is responsible for responding to a "Take" request. The ControlSourcesCommand informs the controlled System/Service of the active controller.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ControlRequest(
	pub crate::v2_5::types::ControlRequestMt,
);
impl Deref for ControlRequest {
	type Target = crate::v2_5::types::ControlRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ControlRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ControlRequestMt> for ControlRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ControlRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ControlRequestMt> for ControlRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ControlRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ControlRequestMt> for ControlRequest {
	fn from(p: crate::v2_5::types::ControlRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ControlRequestMt> for ControlRequest {
	fn into(self) -> crate::v2_5::types::ControlRequestMt {
		self.0
	}
}


#[doc = r#"This message is sent in response to a ControlRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ControlRequestStatus(
	pub crate::v2_5::types::ControlRequestStatusMt,
);
impl Deref for ControlRequestStatus {
	type Target = crate::v2_5::types::ControlRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ControlRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ControlRequestStatusMt> for ControlRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ControlRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ControlRequestStatusMt> for ControlRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ControlRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ControlRequestStatusMt> for ControlRequestStatus {
	fn from(p: crate::v2_5::types::ControlRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ControlRequestStatusMt> for ControlRequestStatus {
	fn into(self) -> crate::v2_5::types::ControlRequestStatusMt {
		self.0
	}
}


#[doc = r#"Indicates a command from a controller to a controllee to establish or change its accepted control sources.  This message is only accepted/obeyed when it comes from the current controlling System (mission control) or the current primary controller (capability control); the current controller receives and adjudicates ControlRequest messages and then uses this message to inform the controllee of the approved control sources.  A controllee reports its current control sources via the ControlStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ControlSourcesCommand(
	pub crate::v2_5::types::ControlSourcesCommandMt,
);
impl Deref for ControlSourcesCommand {
	type Target = crate::v2_5::types::ControlSourcesCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ControlSourcesCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ControlSourcesCommandMt> for ControlSourcesCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ControlSourcesCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ControlSourcesCommandMt> for ControlSourcesCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ControlSourcesCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ControlSourcesCommandMt> for ControlSourcesCommand {
	fn from(p: crate::v2_5::types::ControlSourcesCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ControlSourcesCommandMt> for ControlSourcesCommand {
	fn into(self) -> crate::v2_5::types::ControlSourcesCommandMt {
		self.0
	}
}


#[doc = r#"Indicates the status for a ControlSourcesCommand message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ControlSourcesCommandStatus(
	pub crate::v2_5::types::ControlSourcesCommandStatusMt,
);
impl Deref for ControlSourcesCommandStatus {
	type Target = crate::v2_5::types::ControlSourcesCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ControlSourcesCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ControlSourcesCommandStatusMt> for ControlSourcesCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ControlSourcesCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ControlSourcesCommandStatusMt> for ControlSourcesCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ControlSourcesCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ControlSourcesCommandStatusMt> for ControlSourcesCommandStatus {
	fn from(p: crate::v2_5::types::ControlSourcesCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ControlSourcesCommandStatusMt> for ControlSourcesCommandStatus {
	fn into(self) -> crate::v2_5::types::ControlSourcesCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates who has various levels of control of a System, how the System is configured to be controlled, its autonomous/self-control capability, and its planning capability.  UCI Systems are collections of controllable capabilities that can be pseudo-independently shared/controlled by multiple users; this message indicates the current controllers.  UCI Systems support one or more forms of control via UCI messages/interfaces; this message indicates which categories of UCI control messages are accepted.  UCI Systems have various levels of control automation; this message indicates autonomous/self-control capabilities for each control category.  UCI Systems have a variety of planning processes; this message advertises supported processes.  The messages PlanningFunction*, Approval*, MissionContingencyAlert and ControlStatus are closely related.  They use a common taxonomy of autonomous functions (task allocation, route planning, mission activation and mission execution), triggers for those functions (new threats, new zones, failures, etc.) and results of those functions (dropped Tasks, changes in vulnerability, etc.).  ControlStatus indicates the full set of available autonomous functions/settings of a System.  PlanningFunction* indicates how the available settings are currently configured.  MissionContingencyAlert indicates an autonomous function/setting that has been triggered.  Approval* messages allow Operators to approve the results of autonomous responses as needed.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ControlStatus(
	pub crate::v2_5::types::ControlStatusMt,
);
impl Deref for ControlStatus {
	type Target = crate::v2_5::types::ControlStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ControlStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ControlStatusMt> for ControlStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ControlStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ControlStatusMt> for ControlStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ControlStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ControlStatusMt> for ControlStatus {
	fn from(p: crate::v2_5::types::ControlStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ControlStatusMt> for ControlStatus {
	fn into(self) -> crate::v2_5::types::ControlStatusMt {
		self.0
	}
}


#[doc = r#"Collects a set of linked Requirements which are intended to be executed in a coordinated way to achieve a common objective.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CoordinatedRequirementSet(
	pub crate::v2_5::types::CoordinatedRequirementSetMt,
);
impl Deref for CoordinatedRequirementSet {
	type Target = crate::v2_5::types::CoordinatedRequirementSetMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CoordinatedRequirementSet {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CoordinatedRequirementSetMt> for CoordinatedRequirementSet {
	fn as_ref(&self) -> &crate::v2_5::types::CoordinatedRequirementSetMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CoordinatedRequirementSetMt> for CoordinatedRequirementSet {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CoordinatedRequirementSetMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CoordinatedRequirementSetMt> for CoordinatedRequirementSet {
	fn from(p: crate::v2_5::types::CoordinatedRequirementSetMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CoordinatedRequirementSetMt> for CoordinatedRequirementSet {
	fn into(self) -> crate::v2_5::types::CoordinatedRequirementSetMt {
		self.0
	}
}


#[doc = r#"Status message for a CoordinatedRequirementSet.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CoordinatedRequirementSetStatus(
	pub crate::v2_5::types::CoordinatedRequirementSetStatusMt,
);
impl Deref for CoordinatedRequirementSetStatus {
	type Target = crate::v2_5::types::CoordinatedRequirementSetStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CoordinatedRequirementSetStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CoordinatedRequirementSetStatusMt> for CoordinatedRequirementSetStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CoordinatedRequirementSetStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CoordinatedRequirementSetStatusMt> for CoordinatedRequirementSetStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CoordinatedRequirementSetStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CoordinatedRequirementSetStatusMt> for CoordinatedRequirementSetStatus {
	fn from(p: crate::v2_5::types::CoordinatedRequirementSetStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CoordinatedRequirementSetStatusMt> for CoordinatedRequirementSetStatus {
	fn into(self) -> crate::v2_5::types::CoordinatedRequirementSetStatusMt {
		self.0
	}
}


#[doc = r#"This message represents the activity from a CounterSpace capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CounterSpaceActivity(
	pub crate::v2_5::types::CounterSpaceActivityMt,
);
impl Deref for CounterSpaceActivity {
	type Target = crate::v2_5::types::CounterSpaceActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CounterSpaceActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CounterSpaceActivityMt> for CounterSpaceActivity {
	fn as_ref(&self) -> &crate::v2_5::types::CounterSpaceActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CounterSpaceActivityMt> for CounterSpaceActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CounterSpaceActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CounterSpaceActivityMt> for CounterSpaceActivity {
	fn from(p: crate::v2_5::types::CounterSpaceActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CounterSpaceActivityMt> for CounterSpaceActivity {
	fn into(self) -> crate::v2_5::types::CounterSpaceActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the CS (CounterSpace) category of UCI Capability.  This message "advertises" the mostly static characteristics of a mission-ready CS Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CounterSpaceCapability(
	pub crate::v2_5::types::CounterSpaceCapabilityMt,
);
impl Deref for CounterSpaceCapability {
	type Target = crate::v2_5::types::CounterSpaceCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CounterSpaceCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CounterSpaceCapabilityMt> for CounterSpaceCapability {
	fn as_ref(&self) -> &crate::v2_5::types::CounterSpaceCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CounterSpaceCapabilityMt> for CounterSpaceCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CounterSpaceCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CounterSpaceCapabilityMt> for CounterSpaceCapability {
	fn from(p: crate::v2_5::types::CounterSpaceCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CounterSpaceCapabilityMt> for CounterSpaceCapability {
	fn into(self) -> crate::v2_5::types::CounterSpaceCapabilityMt {
		self.0
	}
}


#[doc = r#"This message represents the EA (Electronic Attack) category of UCI Capability.  This message "advertises" the mostly static characteristics of a mission-ready EA Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CounterSpaceCapabilityStatus(
	pub crate::v2_5::types::CounterSpaceCapabilityStatusMt,
);
impl Deref for CounterSpaceCapabilityStatus {
	type Target = crate::v2_5::types::CounterSpaceCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CounterSpaceCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CounterSpaceCapabilityStatusMt> for CounterSpaceCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CounterSpaceCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CounterSpaceCapabilityStatusMt> for CounterSpaceCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CounterSpaceCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CounterSpaceCapabilityStatusMt> for CounterSpaceCapabilityStatus {
	fn from(p: crate::v2_5::types::CounterSpaceCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CounterSpaceCapabilityStatusMt> for CounterSpaceCapabilityStatus {
	fn into(self) -> crate::v2_5::types::CounterSpaceCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"Provides the constraints and restrictions that must be followed within the CounterSpace mission area.  This is an Order.  The constraints and restrictions are provided by mission partners with the results compiled into a CS deconfliction plan.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CounterSpaceDeconfliction(
	pub crate::v2_5::types::CounterSpaceDeconflictionMt,
);
impl Deref for CounterSpaceDeconfliction {
	type Target = crate::v2_5::types::CounterSpaceDeconflictionMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CounterSpaceDeconfliction {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CounterSpaceDeconflictionMt> for CounterSpaceDeconfliction {
	fn as_ref(&self) -> &crate::v2_5::types::CounterSpaceDeconflictionMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CounterSpaceDeconflictionMt> for CounterSpaceDeconfliction {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CounterSpaceDeconflictionMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CounterSpaceDeconflictionMt> for CounterSpaceDeconfliction {
	fn from(p: crate::v2_5::types::CounterSpaceDeconflictionMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CounterSpaceDeconflictionMt> for CounterSpaceDeconfliction {
	fn into(self) -> crate::v2_5::types::CounterSpaceDeconflictionMt {
		self.0
	}
}


#[doc = r#"The CounterSpaceReport summarizes the RF environment and system activity over a period of time (typically four hours).UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CounterSpaceReport(
	pub crate::v2_5::types::CounterSpaceReportMt,
);
impl Deref for CounterSpaceReport {
	type Target = crate::v2_5::types::CounterSpaceReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CounterSpaceReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CounterSpaceReportMt> for CounterSpaceReport {
	fn as_ref(&self) -> &crate::v2_5::types::CounterSpaceReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CounterSpaceReportMt> for CounterSpaceReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CounterSpaceReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CounterSpaceReportMt> for CounterSpaceReport {
	fn from(p: crate::v2_5::types::CounterSpaceReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CounterSpaceReportMt> for CounterSpaceReport {
	fn into(self) -> crate::v2_5::types::CounterSpaceReportMt {
		self.0
	}
}


#[doc = r#"This message provides the ability to command actions for cryptographic slots.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CryptoCommand(
	pub crate::v2_5::types::CryptoCommandMt,
);
impl Deref for CryptoCommand {
	type Target = crate::v2_5::types::CryptoCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CryptoCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CryptoCommandMt> for CryptoCommand {
	fn as_ref(&self) -> &crate::v2_5::types::CryptoCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CryptoCommandMt> for CryptoCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CryptoCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CryptoCommandMt> for CryptoCommand {
	fn from(p: crate::v2_5::types::CryptoCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CryptoCommandMt> for CryptoCommand {
	fn into(self) -> crate::v2_5::types::CryptoCommandMt {
		self.0
	}
}


#[doc = r#"This message is the response to CryptoCommand and gives the processing status.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CryptoCommandStatus(
	pub crate::v2_5::types::CryptoCommandStatusMt,
);
impl Deref for CryptoCommandStatus {
	type Target = crate::v2_5::types::CryptoCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CryptoCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CryptoCommandStatusMt> for CryptoCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CryptoCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CryptoCommandStatusMt> for CryptoCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CryptoCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CryptoCommandStatusMt> for CryptoCommandStatus {
	fn from(p: crate::v2_5::types::CryptoCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CryptoCommandStatusMt> for CryptoCommandStatus {
	fn into(self) -> crate::v2_5::types::CryptoCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message contains the status and settings for a cryptographic key slot that is relevant to mission operations for a crypto support capability.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct CryptoStatus(
	pub crate::v2_5::types::CryptoStatusMt,
);
impl Deref for CryptoStatus {
	type Target = crate::v2_5::types::CryptoStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for CryptoStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::CryptoStatusMt> for CryptoStatus {
	fn as_ref(&self) -> &crate::v2_5::types::CryptoStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::CryptoStatusMt> for CryptoStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::CryptoStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::CryptoStatusMt> for CryptoStatus {
	fn from(p: crate::v2_5::types::CryptoStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::CryptoStatusMt> for CryptoStatus {
	fn into(self) -> crate::v2_5::types::CryptoStatusMt {
		self.0
	}
}


#[doc = r#"Indicates an assessment of the damage to an item or items in the battlespace.  Damage assessments are either for battle or collateral damage.  An assessment can be requested via the DamageAssessmentRequest message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DamageAssessment(
	pub crate::v2_5::types::DamageAssessmentMt,
);
impl Deref for DamageAssessment {
	type Target = crate::v2_5::types::DamageAssessmentMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DamageAssessment {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DamageAssessmentMt> for DamageAssessment {
	fn as_ref(&self) -> &crate::v2_5::types::DamageAssessmentMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DamageAssessmentMt> for DamageAssessment {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DamageAssessmentMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DamageAssessmentMt> for DamageAssessment {
	fn from(p: crate::v2_5::types::DamageAssessmentMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DamageAssessmentMt> for DamageAssessment {
	fn into(self) -> crate::v2_5::types::DamageAssessmentMt {
		self.0
	}
}


#[doc = r#"This message is used to request an assessment of battle or collateral damage.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DamageAssessmentRequest(
	pub crate::v2_5::types::DamageAssessmentRequestMt,
);
impl Deref for DamageAssessmentRequest {
	type Target = crate::v2_5::types::DamageAssessmentRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DamageAssessmentRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DamageAssessmentRequestMt> for DamageAssessmentRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DamageAssessmentRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DamageAssessmentRequestMt> for DamageAssessmentRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DamageAssessmentRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DamageAssessmentRequestMt> for DamageAssessmentRequest {
	fn from(p: crate::v2_5::types::DamageAssessmentRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DamageAssessmentRequestMt> for DamageAssessmentRequest {
	fn into(self) -> crate::v2_5::types::DamageAssessmentRequestMt {
		self.0
	}
}


#[doc = r#"This message provides status for a DamageAssessmentRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DamageAssessmentRequestStatus(
	pub crate::v2_5::types::DamageAssessmentRequestStatusMt,
);
impl Deref for DamageAssessmentRequestStatus {
	type Target = crate::v2_5::types::DamageAssessmentRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DamageAssessmentRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DamageAssessmentRequestStatusMt> for DamageAssessmentRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DamageAssessmentRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DamageAssessmentRequestStatusMt> for DamageAssessmentRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DamageAssessmentRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DamageAssessmentRequestStatusMt> for DamageAssessmentRequestStatus {
	fn from(p: crate::v2_5::types::DamageAssessmentRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DamageAssessmentRequestStatusMt> for DamageAssessmentRequestStatus {
	fn into(self) -> crate::v2_5::types::DamageAssessmentRequestStatusMt {
		self.0
	}
}


#[doc = r#"Indicates an estimate of the damage that will result from a Task.  Damage estimates are either for battle or collateral damage.  An estimate can be requested via the DamageEstimateRequest message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DamageEstimate(
	pub crate::v2_5::types::DamageEstimateMt,
);
impl Deref for DamageEstimate {
	type Target = crate::v2_5::types::DamageEstimateMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DamageEstimate {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DamageEstimateMt> for DamageEstimate {
	fn as_ref(&self) -> &crate::v2_5::types::DamageEstimateMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DamageEstimateMt> for DamageEstimate {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DamageEstimateMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DamageEstimateMt> for DamageEstimate {
	fn from(p: crate::v2_5::types::DamageEstimateMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DamageEstimateMt> for DamageEstimate {
	fn into(self) -> crate::v2_5::types::DamageEstimateMt {
		self.0
	}
}


#[doc = r#"This message is used to request an estimate of battle or collateral damage.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DamageEstimateRequest(
	pub crate::v2_5::types::DamageEstimateRequestMt,
);
impl Deref for DamageEstimateRequest {
	type Target = crate::v2_5::types::DamageEstimateRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DamageEstimateRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DamageEstimateRequestMt> for DamageEstimateRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DamageEstimateRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DamageEstimateRequestMt> for DamageEstimateRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DamageEstimateRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DamageEstimateRequestMt> for DamageEstimateRequest {
	fn from(p: crate::v2_5::types::DamageEstimateRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DamageEstimateRequestMt> for DamageEstimateRequest {
	fn into(self) -> crate::v2_5::types::DamageEstimateRequestMt {
		self.0
	}
}


#[doc = r#"This message provides status for a DamageEstimateRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DamageEstimateRequestStatus(
	pub crate::v2_5::types::DamageEstimateRequestStatusMt,
);
impl Deref for DamageEstimateRequestStatus {
	type Target = crate::v2_5::types::DamageEstimateRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DamageEstimateRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DamageEstimateRequestStatusMt> for DamageEstimateRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DamageEstimateRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DamageEstimateRequestStatusMt> for DamageEstimateRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DamageEstimateRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DamageEstimateRequestStatusMt> for DamageEstimateRequestStatus {
	fn from(p: crate::v2_5::types::DamageEstimateRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DamageEstimateRequestStatusMt> for DamageEstimateRequestStatus {
	fn into(self) -> crate::v2_5::types::DamageEstimateRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to report battle or collateral damage that has been observed.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DamageReport(
	pub crate::v2_5::types::DamageReportMt,
);
impl Deref for DamageReport {
	type Target = crate::v2_5::types::DamageReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DamageReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DamageReportMt> for DamageReport {
	fn as_ref(&self) -> &crate::v2_5::types::DamageReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DamageReportMt> for DamageReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DamageReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DamageReportMt> for DamageReport {
	fn from(p: crate::v2_5::types::DamageReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DamageReportMt> for DamageReport {
	fn into(self) -> crate::v2_5::types::DamageReportMt {
		self.0
	}
}


#[doc = r#"This message is a summary of all the available damage reports for a given subject.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DamageSummary(
	pub crate::v2_5::types::DamageSummaryMt,
);
impl Deref for DamageSummary {
	type Target = crate::v2_5::types::DamageSummaryMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DamageSummary {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DamageSummaryMt> for DamageSummary {
	fn as_ref(&self) -> &crate::v2_5::types::DamageSummaryMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DamageSummaryMt> for DamageSummary {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DamageSummaryMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DamageSummaryMt> for DamageSummary {
	fn from(p: crate::v2_5::types::DamageSummaryMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DamageSummaryMt> for DamageSummary {
	fn into(self) -> crate::v2_5::types::DamageSummaryMt {
		self.0
	}
}


#[doc = r#"This message requests deletion of non-message data.  It is a request to a data owner to delete products, files or other non-message data.  Message data can be deleted by the publisher/owner using the ObjectState element, independent of this message.  However, when message data is deleted the products, files and other data it references is generally not deleted and therefore this message is needed.  Further "data delete" differs from "erase" and specifically SubsystemEraseCommand in that it requests a "simple" specific delete with no expectation of the subsequent classification level.  This message can also be thought of as a more selective form of DataManagementRequest...Delete.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataDeleteRequest(
	pub crate::v2_5::types::DataDeleteRequestMt,
);
impl Deref for DataDeleteRequest {
	type Target = crate::v2_5::types::DataDeleteRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataDeleteRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataDeleteRequestMt> for DataDeleteRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DataDeleteRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataDeleteRequestMt> for DataDeleteRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataDeleteRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataDeleteRequestMt> for DataDeleteRequest {
	fn from(p: crate::v2_5::types::DataDeleteRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataDeleteRequestMt> for DataDeleteRequest {
	fn into(self) -> crate::v2_5::types::DataDeleteRequestMt {
		self.0
	}
}


#[doc = r#"This message provides status to a DataDeleteRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataDeleteRequestStatus(
	pub crate::v2_5::types::DataDeleteRequestStatusMt,
);
impl Deref for DataDeleteRequestStatus {
	type Target = crate::v2_5::types::DataDeleteRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataDeleteRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataDeleteRequestStatusMt> for DataDeleteRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DataDeleteRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataDeleteRequestStatusMt> for DataDeleteRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataDeleteRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataDeleteRequestStatusMt> for DataDeleteRequestStatus {
	fn from(p: crate::v2_5::types::DataDeleteRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataDeleteRequestStatusMt> for DataDeleteRequestStatus {
	fn into(self) -> crate::v2_5::types::DataDeleteRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies data management activities to be performed on the system as a whole or on a specific service. System-Level data management requests are relative to a mission, and are accomplished by initiating a mission session and requesting that services perform specific actions (i.e., save, import, export, etc.).UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataManagementRequest(
	pub crate::v2_5::types::DataManagementRequestMt,
);
impl Deref for DataManagementRequest {
	type Target = crate::v2_5::types::DataManagementRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataManagementRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataManagementRequestMt> for DataManagementRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DataManagementRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataManagementRequestMt> for DataManagementRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataManagementRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataManagementRequestMt> for DataManagementRequest {
	fn from(p: crate::v2_5::types::DataManagementRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataManagementRequestMt> for DataManagementRequest {
	fn into(self) -> crate::v2_5::types::DataManagementRequestMt {
		self.0
	}
}


#[doc = r#"This message statuses the result of data management activities. These responses can be the result of a request upon an entire "mission session" or a specific service. Services participate in a mission session, and the overall request upon the mission will be decomposed to specific requests to individual services.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataManagementRequestStatus(
	pub crate::v2_5::types::DataManagementRequestStatusMt,
);
impl Deref for DataManagementRequestStatus {
	type Target = crate::v2_5::types::DataManagementRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataManagementRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataManagementRequestStatusMt> for DataManagementRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DataManagementRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataManagementRequestStatusMt> for DataManagementRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataManagementRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataManagementRequestStatusMt> for DataManagementRequestStatus {
	fn from(p: crate::v2_5::types::DataManagementRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataManagementRequestStatusMt> for DataManagementRequestStatus {
	fn into(self) -> crate::v2_5::types::DataManagementRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies the Data Plan that will be applied to Data-Link Gateways during the mission in order to perform ingress and egress of Mission System and Product data.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataPlan(
	pub crate::v2_5::types::DataPlanMt,
);
impl Deref for DataPlan {
	type Target = crate::v2_5::types::DataPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataPlanMt> for DataPlan {
	fn as_ref(&self) -> &crate::v2_5::types::DataPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataPlanMt> for DataPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataPlanMt> for DataPlan {
	fn from(p: crate::v2_5::types::DataPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataPlanMt> for DataPlan {
	fn into(self) -> crate::v2_5::types::DataPlanMt {
		self.0
	}
}


#[doc = r#"This message provides the ability to command upload and activation of a DataPlan.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataPlanActivationCommand(
	pub crate::v2_5::types::DataPlanActivationCommandMt,
);
impl Deref for DataPlanActivationCommand {
	type Target = crate::v2_5::types::DataPlanActivationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataPlanActivationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataPlanActivationCommandMt> for DataPlanActivationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::DataPlanActivationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataPlanActivationCommandMt> for DataPlanActivationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataPlanActivationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataPlanActivationCommandMt> for DataPlanActivationCommand {
	fn from(p: crate::v2_5::types::DataPlanActivationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataPlanActivationCommandMt> for DataPlanActivationCommand {
	fn into(self) -> crate::v2_5::types::DataPlanActivationCommandMt {
		self.0
	}
}


#[doc = r#"This message is the response to a DataPlanActivationCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataPlanActivationCommandStatus(
	pub crate::v2_5::types::DataPlanActivationCommandStatusMt,
);
impl Deref for DataPlanActivationCommandStatus {
	type Target = crate::v2_5::types::DataPlanActivationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataPlanActivationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataPlanActivationCommandStatusMt> for DataPlanActivationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DataPlanActivationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataPlanActivationCommandStatusMt> for DataPlanActivationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataPlanActivationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataPlanActivationCommandStatusMt> for DataPlanActivationCommandStatus {
	fn from(p: crate::v2_5::types::DataPlanActivationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataPlanActivationCommandStatusMt> for DataPlanActivationCommandStatus {
	fn into(self) -> crate::v2_5::types::DataPlanActivationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message provides status of a Data plan along the planning, conversion, upload, and activation chain.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataPlanActivationStatus(
	pub crate::v2_5::types::DataPlanActivationStatusMt,
);
impl Deref for DataPlanActivationStatus {
	type Target = crate::v2_5::types::DataPlanActivationStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataPlanActivationStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataPlanActivationStatusMt> for DataPlanActivationStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DataPlanActivationStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataPlanActivationStatusMt> for DataPlanActivationStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataPlanActivationStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataPlanActivationStatusMt> for DataPlanActivationStatus {
	fn from(p: crate::v2_5::types::DataPlanActivationStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataPlanActivationStatusMt> for DataPlanActivationStatus {
	fn into(self) -> crate::v2_5::types::DataPlanActivationStatusMt {
		self.0
	}
}


#[doc = r#"This message provides an operator the ability to command the activation of pre-mission planned Data-Link gateway settings, in coordination with, operator inputs.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataPlanOverrideRequest(
	pub crate::v2_5::types::DataPlanOverrideRequestMt,
);
impl Deref for DataPlanOverrideRequest {
	type Target = crate::v2_5::types::DataPlanOverrideRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataPlanOverrideRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataPlanOverrideRequestMt> for DataPlanOverrideRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DataPlanOverrideRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataPlanOverrideRequestMt> for DataPlanOverrideRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataPlanOverrideRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataPlanOverrideRequestMt> for DataPlanOverrideRequest {
	fn from(p: crate::v2_5::types::DataPlanOverrideRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataPlanOverrideRequestMt> for DataPlanOverrideRequest {
	fn into(self) -> crate::v2_5::types::DataPlanOverrideRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to a DataPlanOverrideRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataPlanOverrideRequestStatus(
	pub crate::v2_5::types::DataPlanOverrideRequestStatusMt,
);
impl Deref for DataPlanOverrideRequestStatus {
	type Target = crate::v2_5::types::DataPlanOverrideRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataPlanOverrideRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataPlanOverrideRequestStatusMt> for DataPlanOverrideRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DataPlanOverrideRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataPlanOverrideRequestStatusMt> for DataPlanOverrideRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataPlanOverrideRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataPlanOverrideRequestStatusMt> for DataPlanOverrideRequestStatus {
	fn from(p: crate::v2_5::types::DataPlanOverrideRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataPlanOverrideRequestStatusMt> for DataPlanOverrideRequestStatus {
	fn into(self) -> crate::v2_5::types::DataPlanOverrideRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is a request to a data owner to add and/or delete Data Record List Entries to/from a Data Record List in an atomic (all or nothing) manner.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataRecordListManagementRequest(
	pub crate::v2_5::types::DataRecordListManagementRequestMt,
);
impl Deref for DataRecordListManagementRequest {
	type Target = crate::v2_5::types::DataRecordListManagementRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataRecordListManagementRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataRecordListManagementRequestMt> for DataRecordListManagementRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DataRecordListManagementRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataRecordListManagementRequestMt> for DataRecordListManagementRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataRecordListManagementRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataRecordListManagementRequestMt> for DataRecordListManagementRequest {
	fn from(p: crate::v2_5::types::DataRecordListManagementRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataRecordListManagementRequestMt> for DataRecordListManagementRequest {
	fn into(self) -> crate::v2_5::types::DataRecordListManagementRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status of a DataRecordListManagementRequest received by the applicable Data Record List managing interface. In the event that the update was incomplete, this message should provide details on why the update was unsuccessful. If successful, an updated message containing the modified Data Record Lists should also be published with an appropriate ObjectState value.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataRecordListManagementRequestStatus(
	pub crate::v2_5::types::DataRecordListManagementRequestStatusMt,
);
impl Deref for DataRecordListManagementRequestStatus {
	type Target = crate::v2_5::types::DataRecordListManagementRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataRecordListManagementRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataRecordListManagementRequestStatusMt> for DataRecordListManagementRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DataRecordListManagementRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataRecordListManagementRequestStatusMt> for DataRecordListManagementRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataRecordListManagementRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataRecordListManagementRequestStatusMt> for DataRecordListManagementRequestStatus {
	fn from(p: crate::v2_5::types::DataRecordListManagementRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataRecordListManagementRequestStatusMt> for DataRecordListManagementRequestStatus {
	fn into(self) -> crate::v2_5::types::DataRecordListManagementRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is a request to a data owner to create, delete, and/or update Data Records in an atomic (all or nothing) manner.  Data Records that are the subject of a request to delete are indicated by one or more pairs of DataRecordID and MessageType for the purpose of conciseness whereas those that are subject to an update request are provided in totality.  When Data Records are deleted, the products, files, and other data that may be referenced are generally not deleted (see DataDeleteRequest for more details).UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataRecordManagementRequest(
	pub crate::v2_5::types::DataRecordManagementRequestMt,
);
impl Deref for DataRecordManagementRequest {
	type Target = crate::v2_5::types::DataRecordManagementRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataRecordManagementRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataRecordManagementRequestMt> for DataRecordManagementRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DataRecordManagementRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataRecordManagementRequestMt> for DataRecordManagementRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataRecordManagementRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataRecordManagementRequestMt> for DataRecordManagementRequest {
	fn from(p: crate::v2_5::types::DataRecordManagementRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataRecordManagementRequestMt> for DataRecordManagementRequest {
	fn into(self) -> crate::v2_5::types::DataRecordManagementRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status of a DataRecordManagementRequest received by the applicable Data Record Managing Interface. In the event that the update was incomplete, this message should provide details on why the update was unsuccessful. If successful, a new DataRecord message or messages should also be sent with their ObjectState equal to the appropriate value depending on the operation performed.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataRecordManagementRequestStatus(
	pub crate::v2_5::types::DataRecordManagementRequestStatusMt,
);
impl Deref for DataRecordManagementRequestStatus {
	type Target = crate::v2_5::types::DataRecordManagementRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataRecordManagementRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataRecordManagementRequestStatusMt> for DataRecordManagementRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DataRecordManagementRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataRecordManagementRequestStatusMt> for DataRecordManagementRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataRecordManagementRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataRecordManagementRequestStatusMt> for DataRecordManagementRequestStatus {
	fn from(p: crate::v2_5::types::DataRecordManagementRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataRecordManagementRequestStatusMt> for DataRecordManagementRequestStatus {
	fn into(self) -> crate::v2_5::types::DataRecordManagementRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message requests the current data and retention storage availability on the network.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataStorageUtilizationRequest(
	pub crate::v2_5::types::DataStorageUtilizationRequestMt,
);
impl Deref for DataStorageUtilizationRequest {
	type Target = crate::v2_5::types::DataStorageUtilizationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataStorageUtilizationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataStorageUtilizationRequestMt> for DataStorageUtilizationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DataStorageUtilizationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataStorageUtilizationRequestMt> for DataStorageUtilizationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataStorageUtilizationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataStorageUtilizationRequestMt> for DataStorageUtilizationRequest {
	fn from(p: crate::v2_5::types::DataStorageUtilizationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataStorageUtilizationRequestMt> for DataStorageUtilizationRequest {
	fn into(self) -> crate::v2_5::types::DataStorageUtilizationRequestMt {
		self.0
	}
}


#[doc = r#"This message provides a view into the current data retention and storage availability on the network.  For instance, this message would characterize the remaining storage capacity on the network.  A display could request this object to determine if action is required at startup.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataStorageUtilizationRequestStatus(
	pub crate::v2_5::types::DataStorageUtilizationRequestStatusMt,
);
impl Deref for DataStorageUtilizationRequestStatus {
	type Target = crate::v2_5::types::DataStorageUtilizationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataStorageUtilizationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataStorageUtilizationRequestStatusMt> for DataStorageUtilizationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DataStorageUtilizationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataStorageUtilizationRequestStatusMt> for DataStorageUtilizationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataStorageUtilizationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataStorageUtilizationRequestStatusMt> for DataStorageUtilizationRequestStatus {
	fn from(p: crate::v2_5::types::DataStorageUtilizationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataStorageUtilizationRequestStatusMt> for DataStorageUtilizationRequestStatus {
	fn into(self) -> crate::v2_5::types::DataStorageUtilizationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message requests updates for specific units or data types from a specific producing service.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataUpdateRequest(
	pub crate::v2_5::types::DataUpdateRequestMt,
);
impl Deref for DataUpdateRequest {
	type Target = crate::v2_5::types::DataUpdateRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataUpdateRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataUpdateRequestMt> for DataUpdateRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DataUpdateRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataUpdateRequestMt> for DataUpdateRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataUpdateRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataUpdateRequestMt> for DataUpdateRequest {
	fn from(p: crate::v2_5::types::DataUpdateRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataUpdateRequestMt> for DataUpdateRequest {
	fn into(self) -> crate::v2_5::types::DataUpdateRequestMt {
		self.0
	}
}


#[doc = r#"This message provides status for a DataUpdateRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DataUpdateRequestStatus(
	pub crate::v2_5::types::DataUpdateRequestStatusMt,
);
impl Deref for DataUpdateRequestStatus {
	type Target = crate::v2_5::types::DataUpdateRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DataUpdateRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DataUpdateRequestStatusMt> for DataUpdateRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DataUpdateRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DataUpdateRequestStatusMt> for DataUpdateRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DataUpdateRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DataUpdateRequestStatusMt> for DataUpdateRequestStatus {
	fn from(p: crate::v2_5::types::DataUpdateRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DataUpdateRequestStatusMt> for DataUpdateRequestStatus {
	fn into(self) -> crate::v2_5::types::DataUpdateRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the DE Capability of a Subsystem of a System. In general, a [Capability]Activity message describes what invoked Capabilities are doing. It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.). In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability. An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (DE_Command) from an Operator or Capability management Service, 3) currently in-work DE, 4) DE scheduled for the future and 5) DE that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons. A single DE_Command or other triggering event can result in multiple activities within the DE_Activity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DeActivity(
	pub crate::v2_5::types::DeActivityMt,
);
impl Deref for DeActivity {
	type Target = crate::v2_5::types::DeActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DeActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DeActivityMt> for DeActivity {
	fn as_ref(&self) -> &crate::v2_5::types::DeActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DeActivityMt> for DeActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DeActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DeActivityMt> for DeActivity {
	fn from(p: crate::v2_5::types::DeActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DeActivityMt> for DeActivity {
	fn into(self) -> crate::v2_5::types::DeActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the DE (Directed Energy) category of UCI Capability. This message "advertises" the mostly static characteristics of a mission-ready DE Capability (of a Subsystem of System) so that it can be "discovered" and used. "Discovery" can be a misnomer depending on your perspective. UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities. They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number. UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control. In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services. A [Capability]Capability message describes what a Subsystem is capable of doing if invoked. A [Capability]Activity message describes what a Capability is doing. Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others. Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages. Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform. Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DeCapability(
	pub crate::v2_5::types::DeCapabilityMt,
);
impl Deref for DeCapability {
	type Target = crate::v2_5::types::DeCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DeCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DeCapabilityMt> for DeCapability {
	fn as_ref(&self) -> &crate::v2_5::types::DeCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DeCapabilityMt> for DeCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DeCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DeCapabilityMt> for DeCapability {
	fn from(p: crate::v2_5::types::DeCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DeCapabilityMt> for DeCapability {
	fn into(self) -> crate::v2_5::types::DeCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the DE capabilities available to the system. This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc. Since DE capabilities refer specifically to an active capability, an EMCON restriction can result in the DE capabilities being temporarily unavailable.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DeCapabilityStatus(
	pub crate::v2_5::types::DeCapabilityStatusMt,
);
impl Deref for DeCapabilityStatus {
	type Target = crate::v2_5::types::DeCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DeCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DeCapabilityStatusMt> for DeCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DeCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DeCapabilityStatusMt> for DeCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DeCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DeCapabilityStatusMt> for DeCapabilityStatus {
	fn from(p: crate::v2_5::types::DeCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DeCapabilityStatusMt> for DeCapabilityStatus {
	fn into(self) -> crate::v2_5::types::DeCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the DE (Directed Energy) form of the general UCI Capability Command. It is used to manually invoke a Directed Energy Capability to perform a new DE Activity or change an existing interactive DE Activity. It differs from a DE Task because it is intended for direct interaction with the host of the Capability, not a planning Service, and therefore is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan. Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages. Capability Commands can be used in parallel with Tasks, but are generally deferential to them. However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema. Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DeCommand(
	pub crate::v2_5::types::DeCommandMt,
);
impl Deref for DeCommand {
	type Target = crate::v2_5::types::DeCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DeCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DeCommandMt> for DeCommand {
	fn as_ref(&self) -> &crate::v2_5::types::DeCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DeCommandMt> for DeCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DeCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DeCommandMt> for DeCommand {
	fn from(p: crate::v2_5::types::DeCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DeCommandMt> for DeCommand {
	fn into(self) -> crate::v2_5::types::DeCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of a DE_Command. This message will reflect whether the command was received, accepted and/or rejected. This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled. The details of the specific activity or activities that result from the command will report status via the DE_Activity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DeCommandStatus(
	pub crate::v2_5::types::DeCommandStatusMt,
);
impl Deref for DeCommandStatus {
	type Target = crate::v2_5::types::DeCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DeCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DeCommandStatusMt> for DeCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DeCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DeCommandStatusMt> for DeCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DeCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DeCommandStatusMt> for DeCommandStatus {
	fn from(p: crate::v2_5::types::DeCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DeCommandStatusMt> for DeCommandStatus {
	fn into(self) -> crate::v2_5::types::DeCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to request consent to perform a Directed Energy Activity. Status for this command message is provided via the DE_ConsentRequestStatus message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DeConsentRequest(
	pub crate::v2_5::types::DeConsentRequestMt,
);
impl Deref for DeConsentRequest {
	type Target = crate::v2_5::types::DeConsentRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DeConsentRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DeConsentRequestMt> for DeConsentRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DeConsentRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DeConsentRequestMt> for DeConsentRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DeConsentRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DeConsentRequestMt> for DeConsentRequest {
	fn from(p: crate::v2_5::types::DeConsentRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DeConsentRequestMt> for DeConsentRequest {
	fn into(self) -> crate::v2_5::types::DeConsentRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the consent request to perform a Directed Energy Activity.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DeConsentRequestStatus(
	pub crate::v2_5::types::DeConsentRequestStatusMt,
);
impl Deref for DeConsentRequestStatus {
	type Target = crate::v2_5::types::DeConsentRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DeConsentRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DeConsentRequestStatusMt> for DeConsentRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DeConsentRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DeConsentRequestStatusMt> for DeConsentRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DeConsentRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DeConsentRequestStatusMt> for DeConsentRequestStatus {
	fn from(p: crate::v2_5::types::DeConsentRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DeConsentRequestStatusMt> for DeConsentRequestStatus {
	fn into(self) -> crate::v2_5::types::DeConsentRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the DE Capabilities of a Subsystem. [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command. Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DeSettingsCommand(
	pub crate::v2_5::types::DeSettingsCommandMt,
);
impl Deref for DeSettingsCommand {
	type Target = crate::v2_5::types::DeSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DeSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DeSettingsCommandMt> for DeSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::DeSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DeSettingsCommandMt> for DeSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DeSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DeSettingsCommandMt> for DeSettingsCommand {
	fn from(p: crate::v2_5::types::DeSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DeSettingsCommandMt> for DeSettingsCommand {
	fn into(self) -> crate::v2_5::types::DeSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of an DE settings command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DeSettingsCommandStatus(
	pub crate::v2_5::types::DeSettingsCommandStatusMt,
);
impl Deref for DeSettingsCommandStatus {
	type Target = crate::v2_5::types::DeSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DeSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DeSettingsCommandStatusMt> for DeSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DeSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DeSettingsCommandStatusMt> for DeSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DeSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DeSettingsCommandStatusMt> for DeSettingsCommandStatus {
	fn from(p: crate::v2_5::types::DeSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DeSettingsCommandStatusMt> for DeSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::DeSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to explicitly designate one or more specific objects as a target or non-target.  Optionally, the objective of the designation can be given.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Designation(
	pub crate::v2_5::types::DesignationMt,
);
impl Deref for Designation {
	type Target = crate::v2_5::types::DesignationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Designation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DesignationMt> for Designation {
	fn as_ref(&self) -> &crate::v2_5::types::DesignationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DesignationMt> for Designation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DesignationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DesignationMt> for Designation {
	fn from(p: crate::v2_5::types::DesignationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DesignationMt> for Designation {
	fn into(self) -> crate::v2_5::types::DesignationMt {
		self.0
	}
}


#[doc = r#"This message is used to request designation of one or more objects as either a target or a non-target.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DesignationRequest(
	pub crate::v2_5::types::DesignationRequestMt,
);
impl Deref for DesignationRequest {
	type Target = crate::v2_5::types::DesignationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DesignationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DesignationRequestMt> for DesignationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DesignationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DesignationRequestMt> for DesignationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DesignationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DesignationRequestMt> for DesignationRequest {
	fn from(p: crate::v2_5::types::DesignationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DesignationRequestMt> for DesignationRequest {
	fn into(self) -> crate::v2_5::types::DesignationRequestMt {
		self.0
	}
}


#[doc = r#"This message is sent in response to a DesignationRequest message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DesignationRequestStatus(
	pub crate::v2_5::types::DesignationRequestStatusMt,
);
impl Deref for DesignationRequestStatus {
	type Target = crate::v2_5::types::DesignationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DesignationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DesignationRequestStatusMt> for DesignationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DesignationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DesignationRequestStatusMt> for DesignationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DesignationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DesignationRequestStatusMt> for DesignationRequestStatus {
	fn from(p: crate::v2_5::types::DesignationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DesignationRequestStatusMt> for DesignationRequestStatus {
	fn into(self) -> crate::v2_5::types::DesignationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message contains the current status of a discrete within the system.  It is used to report unique data that cannot be reported with other messages.  This is not intended to replace the functionality for system level discretes.  For example, this message could be used to report the WeightOnWheels status for informational use on a display, but the hardwired WeightOnWheels discrete would still be required when needed as a safety interlock.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DiscreteStatus(
	pub crate::v2_5::types::DiscreteStatusMt,
);
impl Deref for DiscreteStatus {
	type Target = crate::v2_5::types::DiscreteStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DiscreteStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DiscreteStatusMt> for DiscreteStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DiscreteStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DiscreteStatusMt> for DiscreteStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DiscreteStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DiscreteStatusMt> for DiscreteStatus {
	fn from(p: crate::v2_5::types::DiscreteStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DiscreteStatusMt> for DiscreteStatus {
	fn into(self) -> crate::v2_5::types::DiscreteStatusMt {
		self.0
	}
}


#[doc = r#"This message represents a single Dynamic Launch Zone (DLZ).UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Dlz(
	pub crate::v2_5::types::DlzMt,
);
impl Deref for Dlz {
	type Target = crate::v2_5::types::DlzMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Dlz {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DlzMt> for Dlz {
	fn as_ref(&self) -> &crate::v2_5::types::DlzMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DlzMt> for Dlz {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DlzMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DlzMt> for Dlz {
	fn from(p: crate::v2_5::types::DlzMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DlzMt> for Dlz {
	fn into(self) -> crate::v2_5::types::DlzMt {
		self.0
	}
}


#[doc = r#"This message is used to request the generation of a Dynamic Launch Zone (DLZ) for a weapon.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DlzRequest(
	pub crate::v2_5::types::DlzRequestMt,
);
impl Deref for DlzRequest {
	type Target = crate::v2_5::types::DlzRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DlzRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DlzRequestMt> for DlzRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DlzRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DlzRequestMt> for DlzRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DlzRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DlzRequestMt> for DlzRequest {
	fn from(p: crate::v2_5::types::DlzRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DlzRequestMt> for DlzRequest {
	fn into(self) -> crate::v2_5::types::DlzRequestMt {
		self.0
	}
}


#[doc = r#"This message provides status for a previously submitted DLZ_Request.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DlzRequestStatus(
	pub crate::v2_5::types::DlzRequestStatusMt,
);
impl Deref for DlzRequestStatus {
	type Target = crate::v2_5::types::DlzRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DlzRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DlzRequestStatusMt> for DlzRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DlzRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DlzRequestStatusMt> for DlzRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DlzRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DlzRequestStatusMt> for DlzRequestStatus {
	fn from(p: crate::v2_5::types::DlzRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DlzRequestStatusMt> for DlzRequestStatus {
	fn into(self) -> crate::v2_5::types::DlzRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message represents a single Designated/Desired Mean Point of Impact (DMPI) for a weapon/store.  The DMPI series of messages are designed to be used collectively to support a variety of use cases by separating data content into independent messages aligned with typical use case actors.  As an example, a dynamic mission planning use case would begin with a strike Task allocated to a System who would refer to it when sending a DMPI_DesignationRequest message.  A targeting cell or other system would then respond with a DMPI_Designation message plus one or more DMPI and DMPI_Status messages and, if applicable, a DMPI_Pattern message.  The System which the strike Task was allocated to (or its representative) would then report DMPI_Status as the strike Task proceeds.  A variety of pre-mission and other use cases are also supported.  For example, a targeting cell or other System could provide DMPI_Designation and/or DMPI messages independent of strike Tasks by omitting the DMPI_DesignationRequest message from the use case described above.
A single DMPI can have multiple desired weapons/stores.  See annotations for the DMPI_Status message for further details.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Dmpi(
	pub crate::v2_5::types::DmpiMt,
);
impl Deref for Dmpi {
	type Target = crate::v2_5::types::DmpiMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Dmpi {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DmpiMt> for Dmpi {
	fn as_ref(&self) -> &crate::v2_5::types::DmpiMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DmpiMt> for Dmpi {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DmpiMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DmpiMt> for Dmpi {
	fn from(p: crate::v2_5::types::DmpiMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DmpiMt> for Dmpi {
	fn into(self) -> crate::v2_5::types::DmpiMt {
		self.0
	}
}


#[doc = r#"This message is a request to cancel a previously planned and allocated DMPI.  A planning input such as MetaTask, Task and DMPI can't easily be canceled or removed from the System due to race conditions between their various users and publishers, inevitability of the associated action, etc.  Additionally, the operator or service initiating the cancellation might be different than the one that manages the DMPI.  In order to avoid race conditions, receive positive feedback on the success of the cancellation and allow canceled messages/objects to remain in the system for historical purposes, an explicit DMPI_CancelCommand is necessary.  A DMPI_CancelCommand shall result in the DMPI being canceled unless execution was already inevitable.  Status or feedback for this message is given through DMPI_Status.  Therefore, it does not form a typical request/response pair.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DmpiCancelCommand(
	pub crate::v2_5::types::DmpiCancelCommandMt,
);
impl Deref for DmpiCancelCommand {
	type Target = crate::v2_5::types::DmpiCancelCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DmpiCancelCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DmpiCancelCommandMt> for DmpiCancelCommand {
	fn as_ref(&self) -> &crate::v2_5::types::DmpiCancelCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DmpiCancelCommandMt> for DmpiCancelCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DmpiCancelCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DmpiCancelCommandMt> for DmpiCancelCommand {
	fn from(p: crate::v2_5::types::DmpiCancelCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DmpiCancelCommandMt> for DmpiCancelCommand {
	fn into(self) -> crate::v2_5::types::DmpiCancelCommandMt {
		self.0
	}
}


#[doc = r#"This message is sent in response to a DMPI_CancelCommand and indicates if the DMPI was canceled and if not why it was not canceled.  The resulting status of the DMPI is reported in DMPI_Status.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DmpiCancelCommandStatus(
	pub crate::v2_5::types::DmpiCancelCommandStatusMt,
);
impl Deref for DmpiCancelCommandStatus {
	type Target = crate::v2_5::types::DmpiCancelCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DmpiCancelCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DmpiCancelCommandStatusMt> for DmpiCancelCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DmpiCancelCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DmpiCancelCommandStatusMt> for DmpiCancelCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DmpiCancelCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DmpiCancelCommandStatusMt> for DmpiCancelCommandStatus {
	fn from(p: crate::v2_5::types::DmpiCancelCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DmpiCancelCommandStatusMt> for DmpiCancelCommandStatus {
	fn into(self) -> crate::v2_5::types::DmpiCancelCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies a set of DMPIs or a DMPI pattern for a given target.  This message can be a response to DMPI_DesignationRequest.  It can also be sent independently as a means of establishing a DMPI designation or pattern during pre-mission planning or at any other time prior to being requested.  See the annotations for the DMPI message for an overview of the entire DMPI series of messages.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DmpiDesignation(
	pub crate::v2_5::types::DmpiDesignationMt,
);
impl Deref for DmpiDesignation {
	type Target = crate::v2_5::types::DmpiDesignationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DmpiDesignation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DmpiDesignationMt> for DmpiDesignation {
	fn as_ref(&self) -> &crate::v2_5::types::DmpiDesignationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DmpiDesignationMt> for DmpiDesignation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DmpiDesignationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DmpiDesignationMt> for DmpiDesignation {
	fn from(p: crate::v2_5::types::DmpiDesignationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DmpiDesignationMt> for DmpiDesignation {
	fn into(self) -> crate::v2_5::types::DmpiDesignationMt {
		self.0
	}
}


#[doc = r#"This message is used to request DMPIs (to target an Entity) from a targeting cell or other node.  See the annotations for the DMPI message for an overview of the entire DMPI series of messages.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DmpiDesignationRequest(
	pub crate::v2_5::types::DmpiDesignationRequestMt,
);
impl Deref for DmpiDesignationRequest {
	type Target = crate::v2_5::types::DmpiDesignationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DmpiDesignationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DmpiDesignationRequestMt> for DmpiDesignationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::DmpiDesignationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DmpiDesignationRequestMt> for DmpiDesignationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DmpiDesignationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DmpiDesignationRequestMt> for DmpiDesignationRequest {
	fn from(p: crate::v2_5::types::DmpiDesignationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DmpiDesignationRequestMt> for DmpiDesignationRequest {
	fn into(self) -> crate::v2_5::types::DmpiDesignationRequestMt {
		self.0
	}
}


#[doc = r#"This message provides status for a DMPI_DesignationRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DmpiDesignationRequestStatus(
	pub crate::v2_5::types::DmpiDesignationRequestStatusMt,
);
impl Deref for DmpiDesignationRequestStatus {
	type Target = crate::v2_5::types::DmpiDesignationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DmpiDesignationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DmpiDesignationRequestStatusMt> for DmpiDesignationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DmpiDesignationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DmpiDesignationRequestStatusMt> for DmpiDesignationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DmpiDesignationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DmpiDesignationRequestStatusMt> for DmpiDesignationRequestStatus {
	fn from(p: crate::v2_5::types::DmpiDesignationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DmpiDesignationRequestStatusMt> for DmpiDesignationRequestStatus {
	fn into(self) -> crate::v2_5::types::DmpiDesignationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message represents a pattern or group of DMPIs.  DMPI patterns are used to express spatial relationships between DMPIs of a single target.  See the annotations for the DMPI message for an overview of the entire DMPI series of messages.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DmpiPattern(
	pub crate::v2_5::types::DmpiPatternMt,
);
impl Deref for DmpiPattern {
	type Target = crate::v2_5::types::DmpiPatternMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DmpiPattern {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DmpiPatternMt> for DmpiPattern {
	fn as_ref(&self) -> &crate::v2_5::types::DmpiPatternMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DmpiPatternMt> for DmpiPattern {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DmpiPatternMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DmpiPatternMt> for DmpiPattern {
	fn from(p: crate::v2_5::types::DmpiPatternMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DmpiPatternMt> for DmpiPattern {
	fn into(self) -> crate::v2_5::types::DmpiPatternMt {
		self.0
	}
}


#[doc = r#"This message provides the status of a DMPI as it progresses through its life cycle.
For a single store DMPI (a DMPI that will be attacked with a single weapon/store), there is at most one associated Task and this message gives the complete status relative to it.  Similarly for a multiple store DMPI associated with a single Task.
For a multiple store DMPI associated with multiple Tasks this element provides partial status for one Task.  Multiple DMPI_Status messages from multiple sources are expected in this case, each referencing the same DMPI_ID but different Tasks, Systems and/or mission plans.
See the annotations for the DMPI message for an overview of the entire DMPI series of messages.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DmpiStatus(
	pub crate::v2_5::types::DmpiStatusMt,
);
impl Deref for DmpiStatus {
	type Target = crate::v2_5::types::DmpiStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DmpiStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DmpiStatusMt> for DmpiStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DmpiStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DmpiStatusMt> for DmpiStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DmpiStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DmpiStatusMt> for DmpiStatus {
	fn from(p: crate::v2_5::types::DmpiStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DmpiStatusMt> for DmpiStatus {
	fn into(self) -> crate::v2_5::types::DmpiStatusMt {
		self.0
	}
}


#[doc = r#"This message commands the weapons door to be opened or closed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DoorCommand(
	pub crate::v2_5::types::DoorCommandMt,
);
impl Deref for DoorCommand {
	type Target = crate::v2_5::types::DoorCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DoorCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DoorCommandMt> for DoorCommand {
	fn as_ref(&self) -> &crate::v2_5::types::DoorCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DoorCommandMt> for DoorCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DoorCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DoorCommandMt> for DoorCommand {
	fn from(p: crate::v2_5::types::DoorCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DoorCommandMt> for DoorCommand {
	fn into(self) -> crate::v2_5::types::DoorCommandMt {
		self.0
	}
}


#[doc = r#"The message indicates the receipt, acceptance, or rejection of the corresponding DoorCommand message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DoorCommandStatus(
	pub crate::v2_5::types::DoorCommandStatusMt,
);
impl Deref for DoorCommandStatus {
	type Target = crate::v2_5::types::DoorCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DoorCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DoorCommandStatusMt> for DoorCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DoorCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DoorCommandStatusMt> for DoorCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DoorCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DoorCommandStatusMt> for DoorCommandStatus {
	fn from(p: crate::v2_5::types::DoorCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DoorCommandStatusMt> for DoorCommandStatus {
	fn into(self) -> crate::v2_5::types::DoorCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message contains information regarding the status of the weapons door for a support capability  that is relevant to mission operations.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct DoorStatus(
	pub crate::v2_5::types::DoorStatusMt,
);
impl Deref for DoorStatus {
	type Target = crate::v2_5::types::DoorStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for DoorStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::DoorStatusMt> for DoorStatus {
	fn as_ref(&self) -> &crate::v2_5::types::DoorStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::DoorStatusMt> for DoorStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::DoorStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::DoorStatusMt> for DoorStatus {
	fn from(p: crate::v2_5::types::DoorStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::DoorStatusMt> for DoorStatus {
	fn into(self) -> crate::v2_5::types::DoorStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the EA Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (EA_Command) from an Operator or Capability management Service, 3) currently in-work EA, 4) EA scheduled for the future and 5) EA that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single EA_Command or other triggering event can result in multiple activities within the EA_Activity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EaActivity(
	pub crate::v2_5::types::EaActivityMt,
);
impl Deref for EaActivity {
	type Target = crate::v2_5::types::EaActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EaActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EaActivityMt> for EaActivity {
	fn as_ref(&self) -> &crate::v2_5::types::EaActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EaActivityMt> for EaActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EaActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EaActivityMt> for EaActivity {
	fn from(p: crate::v2_5::types::EaActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EaActivityMt> for EaActivity {
	fn into(self) -> crate::v2_5::types::EaActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the EA (Electronic Attack) category of UCI Capability.  This message "advertises" the mostly static characteristics of a mission-ready EA Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EaCapability(
	pub crate::v2_5::types::EaCapabilityMt,
);
impl Deref for EaCapability {
	type Target = crate::v2_5::types::EaCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EaCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EaCapabilityMt> for EaCapability {
	fn as_ref(&self) -> &crate::v2_5::types::EaCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EaCapabilityMt> for EaCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EaCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EaCapabilityMt> for EaCapability {
	fn from(p: crate::v2_5::types::EaCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EaCapabilityMt> for EaCapability {
	fn into(self) -> crate::v2_5::types::EaCapabilityMt {
		self.0
	}
}


#[doc = r#"This message is used to report the current status of the EA (Electronic Attack) capabilities available to the system as advertised in the EA_Capability message.  This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EaCapabilityStatus(
	pub crate::v2_5::types::EaCapabilityStatusMt,
);
impl Deref for EaCapabilityStatus {
	type Target = crate::v2_5::types::EaCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EaCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EaCapabilityStatusMt> for EaCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EaCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EaCapabilityStatusMt> for EaCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EaCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EaCapabilityStatusMt> for EaCapabilityStatus {
	fn from(p: crate::v2_5::types::EaCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EaCapabilityStatusMt> for EaCapabilityStatus {
	fn into(self) -> crate::v2_5::types::EaCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the EA (Electronic Attack) form of the general UCI Capability Command.  It is used to manually invoke an EA Capability to perform a new EA Activity or change an existing interactive EA Activity.  It differs from an EA Task because it is intended for direct interaction with the host of the Capability, not a planning Service, and therefore is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan.  Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages.  Capability Commands can be used in parallel with Tasks, but are generally deferential to them.  However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EaCommand(
	pub crate::v2_5::types::EaCommandMt,
);
impl Deref for EaCommand {
	type Target = crate::v2_5::types::EaCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EaCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EaCommandMt> for EaCommand {
	fn as_ref(&self) -> &crate::v2_5::types::EaCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EaCommandMt> for EaCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EaCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EaCommandMt> for EaCommand {
	fn from(p: crate::v2_5::types::EaCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EaCommandMt> for EaCommand {
	fn into(self) -> crate::v2_5::types::EaCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an EA_Command.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the EA_Activity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EaCommandStatus(
	pub crate::v2_5::types::EaCommandStatusMt,
);
impl Deref for EaCommandStatus {
	type Target = crate::v2_5::types::EaCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EaCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EaCommandStatusMt> for EaCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EaCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EaCommandStatusMt> for EaCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EaCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EaCommandStatusMt> for EaCommandStatus {
	fn from(p: crate::v2_5::types::EaCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EaCommandStatusMt> for EaCommandStatus {
	fn into(self) -> crate::v2_5::types::EaCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to request consent to perform EA.  Status for this command message is provided via the EA_ConsentRequestStatus message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EaConsentRequest(
	pub crate::v2_5::types::EaConsentRequestMt,
);
impl Deref for EaConsentRequest {
	type Target = crate::v2_5::types::EaConsentRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EaConsentRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EaConsentRequestMt> for EaConsentRequest {
	fn as_ref(&self) -> &crate::v2_5::types::EaConsentRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EaConsentRequestMt> for EaConsentRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EaConsentRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EaConsentRequestMt> for EaConsentRequest {
	fn from(p: crate::v2_5::types::EaConsentRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EaConsentRequestMt> for EaConsentRequest {
	fn into(self) -> crate::v2_5::types::EaConsentRequestMt {
		self.0
	}
}


#[doc = r#"This message is used to report consent request status for its corresponding EA_ConsentRequest message used to perform Electronic Attack (EA) capabilities.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EaConsentRequestStatus(
	pub crate::v2_5::types::EaConsentRequestStatusMt,
);
impl Deref for EaConsentRequestStatus {
	type Target = crate::v2_5::types::EaConsentRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EaConsentRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EaConsentRequestStatusMt> for EaConsentRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EaConsentRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EaConsentRequestStatusMt> for EaConsentRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EaConsentRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EaConsentRequestStatusMt> for EaConsentRequestStatus {
	fn from(p: crate::v2_5::types::EaConsentRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EaConsentRequestStatusMt> for EaConsentRequestStatus {
	fn into(self) -> crate::v2_5::types::EaConsentRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the EA Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EaSettingsCommand(
	pub crate::v2_5::types::EaSettingsCommandMt,
);
impl Deref for EaSettingsCommand {
	type Target = crate::v2_5::types::EaSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EaSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EaSettingsCommandMt> for EaSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::EaSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EaSettingsCommandMt> for EaSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EaSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EaSettingsCommandMt> for EaSettingsCommand {
	fn from(p: crate::v2_5::types::EaSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EaSettingsCommandMt> for EaSettingsCommand {
	fn into(self) -> crate::v2_5::types::EaSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message is used to report settings status for its corresponding EA_SettingsCommand message used to change the settings associated with its advertised Electronic Attack (EA) capabilities.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EaSettingsCommandStatus(
	pub crate::v2_5::types::EaSettingsCommandStatusMt,
);
impl Deref for EaSettingsCommandStatus {
	type Target = crate::v2_5::types::EaSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EaSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EaSettingsCommandStatusMt> for EaSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EaSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EaSettingsCommandStatusMt> for EaSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EaSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EaSettingsCommandStatusMt> for EaSettingsCommandStatus {
	fn from(p: crate::v2_5::types::EaSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EaSettingsCommandStatusMt> for EaSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::EaSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to report characteristics of and corrections for perturbations of earth's rotation and orbit around the sun.  Perturbation forces include those from the gravitational force of the moon, the oblate shape of the earth and the tilt and "wobble" of the earth's rotational axis.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EarthOrientationParameters(
	pub crate::v2_5::types::EarthOrientationParametersMt,
);
impl Deref for EarthOrientationParameters {
	type Target = crate::v2_5::types::EarthOrientationParametersMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EarthOrientationParameters {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EarthOrientationParametersMt> for EarthOrientationParameters {
	fn as_ref(&self) -> &crate::v2_5::types::EarthOrientationParametersMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EarthOrientationParametersMt> for EarthOrientationParameters {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EarthOrientationParametersMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EarthOrientationParametersMt> for EarthOrientationParameters {
	fn from(p: crate::v2_5::types::EarthOrientationParametersMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EarthOrientationParametersMt> for EarthOrientationParameters {
	fn into(self) -> crate::v2_5::types::EarthOrientationParametersMt {
		self.0
	}
}


#[doc = r#"This message contains, Essential Elements of Information (EEI); ad-hoc free text that describes information which is referred to during tasking and mission planning.  EEI are used to describe essential information that may not be available in other UCI messages.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Eei(
	pub crate::v2_5::types::EeiMt,
);
impl Deref for Eei {
	type Target = crate::v2_5::types::EeiMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Eei {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EeiMt> for Eei {
	fn as_ref(&self) -> &crate::v2_5::types::EeiMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EeiMt> for Eei {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EeiMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EeiMt> for Eei {
	fn from(p: crate::v2_5::types::EeiMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EeiMt> for Eei {
	fn into(self) -> crate::v2_5::types::EeiMt {
		self.0
	}
}


#[doc = r#"This message specifies a C2 Requirement in the form/abstraction of an Effect.  Other C2 Requirement forms include Action, Task, [Capability]Command and  Response.  For example, a DEFEAT Effect could be planned/decomposed into a FIND Action, SAR Task, SAR_Command, Attack Action and Strike Task.  See the child EffectType element and its enumerates for the Effect taxonomy.  Effects can be planned (*Plan messages), directly commanded (EffectCommand* messages) and/or event-driven responses (Response* messages).UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Effect(
	pub crate::v2_5::types::EffectMt,
);
impl Deref for Effect {
	type Target = crate::v2_5::types::EffectMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Effect {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectMt> for Effect {
	fn as_ref(&self) -> &crate::v2_5::types::EffectMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectMt> for Effect {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectMt> for Effect {
	fn from(p: crate::v2_5::types::EffectMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectMt> for Effect {
	fn into(self) -> crate::v2_5::types::EffectMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the Effect Capability of a System.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectActivity(
	pub crate::v2_5::types::EffectActivityMt,
);
impl Deref for EffectActivity {
	type Target = crate::v2_5::types::EffectActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectActivityMt> for EffectActivity {
	fn as_ref(&self) -> &crate::v2_5::types::EffectActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectActivityMt> for EffectActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectActivityMt> for EffectActivity {
	fn from(p: crate::v2_5::types::EffectActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectActivityMt> for EffectActivity {
	fn into(self) -> crate::v2_5::types::EffectActivityMt {
		self.0
	}
}


#[doc = r#"This message is a request to cancel an Effect which has been allocated and planned.  A planning input such as Effect, Action, Task and DMPI can't easily be canceled or removed from the System due to race conditions between their various users and publishers, inevitability of the associated activity, etc.  Additionally, the operator or service initiating the cancellation might be different than the one that manages RequirementSets and/or issues *PlanCommand, introducing additional race conditions.  In order to avoid race conditions, receive positive feedback on the success of the cancellation and allow canceled messages/objects to remain in the system for historical purposes, an explicit EffectCancelCommand is necessary.  An EffectCancelCommand shall result in the Effect being canceled unless execution was already inevitable.  If the Effect was inevitable and started executing but can be stopped (such as a long collection Effect) it shall cancel as soon as possible.  EffectCancelCommand shall result in managers of RequirementSets to remove the associated Effect, thereby removing the Effect from the next planning cycle.  Services other than those that manage RequirementSets and execute activities aren't required to handle EffectCancelCommand.  EffectCancelCommand doesn't necessarily trigger a replan (there isn't a corresponding planning trigger), therefore a System could continue to navigate routes related to the canceled Effect, even though the Effect won't occur.  A subsequent replan could exclude the Effect.  Status or feedback for this message is given through EffectCancelCommandStatus but the resulting status of the Effect is given through EffectStatus.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectCancelCommand(
	pub crate::v2_5::types::EffectCancelCommandMt,
);
impl Deref for EffectCancelCommand {
	type Target = crate::v2_5::types::EffectCancelCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectCancelCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectCancelCommandMt> for EffectCancelCommand {
	fn as_ref(&self) -> &crate::v2_5::types::EffectCancelCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectCancelCommandMt> for EffectCancelCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectCancelCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectCancelCommandMt> for EffectCancelCommand {
	fn from(p: crate::v2_5::types::EffectCancelCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectCancelCommandMt> for EffectCancelCommand {
	fn into(self) -> crate::v2_5::types::EffectCancelCommandMt {
		self.0
	}
}


#[doc = r#"This message is sent in response to an EffectCancelCommand and indicates if the Effect was canceled and if not why it was not canceled.  The resulting status of the Effect is reported in EffectStatus.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectCancelCommandStatus(
	pub crate::v2_5::types::EffectCancelCommandStatusMt,
);
impl Deref for EffectCancelCommandStatus {
	type Target = crate::v2_5::types::EffectCancelCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectCancelCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectCancelCommandStatusMt> for EffectCancelCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EffectCancelCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectCancelCommandStatusMt> for EffectCancelCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectCancelCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectCancelCommandStatusMt> for EffectCancelCommandStatus {
	fn from(p: crate::v2_5::types::EffectCancelCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectCancelCommandStatusMt> for EffectCancelCommandStatus {
	fn into(self) -> crate::v2_5::types::EffectCancelCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message represents the Effect category of UCI Capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectCapability(
	pub crate::v2_5::types::EffectCapabilityMt,
);
impl Deref for EffectCapability {
	type Target = crate::v2_5::types::EffectCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectCapabilityMt> for EffectCapability {
	fn as_ref(&self) -> &crate::v2_5::types::EffectCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectCapabilityMt> for EffectCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectCapabilityMt> for EffectCapability {
	fn from(p: crate::v2_5::types::EffectCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectCapabilityMt> for EffectCapability {
	fn into(self) -> crate::v2_5::types::EffectCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Effect capabilities available to the system.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectCapabilityStatus(
	pub crate::v2_5::types::EffectCapabilityStatusMt,
);
impl Deref for EffectCapabilityStatus {
	type Target = crate::v2_5::types::EffectCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectCapabilityStatusMt> for EffectCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EffectCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectCapabilityStatusMt> for EffectCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectCapabilityStatusMt> for EffectCapabilityStatus {
	fn from(p: crate::v2_5::types::EffectCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectCapabilityStatusMt> for EffectCapabilityStatus {
	fn into(self) -> crate::v2_5::types::EffectCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the Effect form of the general UCI Capability Command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectCommand(
	pub crate::v2_5::types::EffectCommandMt,
);
impl Deref for EffectCommand {
	type Target = crate::v2_5::types::EffectCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectCommandMt> for EffectCommand {
	fn as_ref(&self) -> &crate::v2_5::types::EffectCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectCommandMt> for EffectCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectCommandMt> for EffectCommand {
	fn from(p: crate::v2_5::types::EffectCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectCommandMt> for EffectCommand {
	fn into(self) -> crate::v2_5::types::EffectCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an EffectCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectCommandStatus(
	pub crate::v2_5::types::EffectCommandStatusMt,
);
impl Deref for EffectCommandStatus {
	type Target = crate::v2_5::types::EffectCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectCommandStatusMt> for EffectCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EffectCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectCommandStatusMt> for EffectCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectCommandStatusMt> for EffectCommandStatus {
	fn from(p: crate::v2_5::types::EffectCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectCommandStatusMt> for EffectCommandStatus {
	fn into(self) -> crate::v2_5::types::EffectCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the state of approval for execution of a task. ApprovalPolicy allow an authority to define policies to approve or reject a Effect as it enters execution. Approval may or may not be required. If approval is required, there can be multiple approvers. See Approval* messages for additional details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectExecutionApprovalStatus(
	pub crate::v2_5::types::EffectExecutionApprovalStatusMt,
);
impl Deref for EffectExecutionApprovalStatus {
	type Target = crate::v2_5::types::EffectExecutionApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectExecutionApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectExecutionApprovalStatusMt> for EffectExecutionApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EffectExecutionApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectExecutionApprovalStatusMt> for EffectExecutionApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectExecutionApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectExecutionApprovalStatusMt> for EffectExecutionApprovalStatus {
	fn from(p: crate::v2_5::types::EffectExecutionApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectExecutionApprovalStatusMt> for EffectExecutionApprovalStatus {
	fn into(self) -> crate::v2_5::types::EffectExecutionApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies the Effects allocated to a System.  Allocation can be done manually by operators, by an allocation service or a combination.  This message decouples Effect allocation from kinematic, action and other types of planning; Effect allocations can be created, updated and approved independent of other *Plans.  It enables any type of *Plan to be a constraint on Effect allocation.	
An EffectPlan can be an input and/or output of planning processes.  For example the EffectPlan for the top System in a hierarchical System of System could be an input to an Effect allocation service that the produces an EffectPlan per subordinate System with their subset of allocated Effects.
Additional details such as timing, dependencies, decomposition, etc. can be added during the Effect allocation process and captured in the EffectPlan to supplement the information in the allocated Effects themselves.
An EffectPlan can be created discretely or as part of a MissionPlan that includes other *Plans.  An EffectPlan can only be activated and executed as part of a MissionPlan.  A MissionPlan can be used to plan the execution order of multiple EffectPlans and *Plans in general.  An EffectPlan can be subject to approval per Approval* messages.  Planning, approval, activation and execution state information for an EffectPlan are given in other EffectPlan* messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectPlan(
	pub crate::v2_5::types::EffectPlanMt,
);
impl Deref for EffectPlan {
	type Target = crate::v2_5::types::EffectPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectPlanMt> for EffectPlan {
	fn as_ref(&self) -> &crate::v2_5::types::EffectPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectPlanMt> for EffectPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectPlanMt> for EffectPlan {
	fn from(p: crate::v2_5::types::EffectPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectPlanMt> for EffectPlan {
	fn into(self) -> crate::v2_5::types::EffectPlanMt {
		self.0
	}
}


#[doc = r#"This message indicates status/state of approval for an EffectPlan.  Approval may or may not be required.  ApprovalPolicy aligned with the *Plans and states of planning allow a planning oversight authority to approve or reject plans as they're created or updated.  Approval may or may not be required.  If required, there may be many approvers.  See Approval* messages for additional details.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectPlanApprovalStatus(
	pub crate::v2_5::types::EffectPlanApprovalStatusMt,
);
impl Deref for EffectPlanApprovalStatus {
	type Target = crate::v2_5::types::EffectPlanApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectPlanApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectPlanApprovalStatusMt> for EffectPlanApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EffectPlanApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectPlanApprovalStatusMt> for EffectPlanApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectPlanApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectPlanApprovalStatusMt> for EffectPlanApprovalStatus {
	fn from(p: crate::v2_5::types::EffectPlanApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectPlanApprovalStatusMt> for EffectPlanApprovalStatus {
	fn into(self) -> crate::v2_5::types::EffectPlanApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message invokes an EffectPlan planning process.  Each planning process is declared with a unique ID in the ControlStatus message; that ID is used in this message to invoke the process.  This message includes many inputs to the planning process but many others may come from a variety of other messages.  A few examples of the many inputs include:
1. Options for constraining the planning function in a variety of ways using existing Plans of the same type or by other Plan types.  For example, an EffectPlan could be constrained by a previous RoutePlan, a previous RouteActivityPlan and/or a TaskPlan.
2. Environment overrides to selectively modify details of the current planning environment in the context of a single planning command. For example, a known threat Entity in the environment could be removed and an expected Entity could be added to the environment in the context of a single planning command in support of "what-if" planning.
3. "Weightings" that influence the decisions of operators or planning algorithms performing the planning.
4. Temporal and/or kinematic begin and end points.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectPlanCommand(
	pub crate::v2_5::types::EffectPlanCommandMt,
);
impl Deref for EffectPlanCommand {
	type Target = crate::v2_5::types::EffectPlanCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectPlanCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectPlanCommandMt> for EffectPlanCommand {
	fn as_ref(&self) -> &crate::v2_5::types::EffectPlanCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectPlanCommandMt> for EffectPlanCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectPlanCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectPlanCommandMt> for EffectPlanCommand {
	fn from(p: crate::v2_5::types::EffectPlanCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectPlanCommandMt> for EffectPlanCommand {
	fn into(self) -> crate::v2_5::types::EffectPlanCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to create/update an EffectPlan, including the current state in a command and processing state machine; see the EffectPlanCommand message.  Creation/update of an EffectPlan  may occur autonomously, without an EffectPlanCommand in which case the current state of the plan could be given in the EffectPlanStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectPlanCommandStatus(
	pub crate::v2_5::types::EffectPlanCommandStatusMt,
);
impl Deref for EffectPlanCommandStatus {
	type Target = crate::v2_5::types::EffectPlanCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectPlanCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectPlanCommandStatusMt> for EffectPlanCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EffectPlanCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectPlanCommandStatusMt> for EffectPlanCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectPlanCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectPlanCommandStatusMt> for EffectPlanCommandStatus {
	fn from(p: crate::v2_5::types::EffectPlanCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectPlanCommandStatusMt> for EffectPlanCommandStatus {
	fn into(self) -> crate::v2_5::types::EffectPlanCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the execution status for one or more EffectPlans.  Plan execution begins after successful autonomous plan activation or activation via EffectPlanActivation messages.  This message provides execution status regardless of how execution was initiated.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectPlanExecutionStatus(
	pub crate::v2_5::types::EffectPlanExecutionStatusMt,
);
impl Deref for EffectPlanExecutionStatus {
	type Target = crate::v2_5::types::EffectPlanExecutionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectPlanExecutionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectPlanExecutionStatusMt> for EffectPlanExecutionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EffectPlanExecutionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectPlanExecutionStatusMt> for EffectPlanExecutionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectPlanExecutionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectPlanExecutionStatusMt> for EffectPlanExecutionStatus {
	fn from(p: crate::v2_5::types::EffectPlanExecutionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectPlanExecutionStatusMt> for EffectPlanExecutionStatus {
	fn into(self) -> crate::v2_5::types::EffectPlanExecutionStatusMt {
		self.0
	}
}


#[doc = r#"This message provides status for an EffectPlan.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectPlanStatus(
	pub crate::v2_5::types::EffectPlanStatusMt,
);
impl Deref for EffectPlanStatus {
	type Target = crate::v2_5::types::EffectPlanStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectPlanStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectPlanStatusMt> for EffectPlanStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EffectPlanStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectPlanStatusMt> for EffectPlanStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectPlanStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectPlanStatusMt> for EffectPlanStatus {
	fn from(p: crate::v2_5::types::EffectPlanStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectPlanStatusMt> for EffectPlanStatus {
	fn into(self) -> crate::v2_5::types::EffectPlanStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the validation, including the current state in a validation state machine, and details of invalid items. Validation may occur periodically, or onesie twosie. See the EffectPlanValidationCommand message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectPlanValidation(
	pub crate::v2_5::types::EffectPlanValidationMt,
);
impl Deref for EffectPlanValidation {
	type Target = crate::v2_5::types::EffectPlanValidationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectPlanValidation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectPlanValidationMt> for EffectPlanValidation {
	fn as_ref(&self) -> &crate::v2_5::types::EffectPlanValidationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectPlanValidationMt> for EffectPlanValidation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectPlanValidationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectPlanValidationMt> for EffectPlanValidation {
	fn from(p: crate::v2_5::types::EffectPlanValidationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectPlanValidationMt> for EffectPlanValidation {
	fn into(self) -> crate::v2_5::types::EffectPlanValidationMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to validate/re-validate an existing EffectPlan.  An EffectPlan can become invalid due to changes in Effect timing, weather, order of battle, kinematic movement constraints, operator manual edits and many, many other reasons.  The message allows an existing EffectPlan to be checked for validity given such changes.  The variables a given planning service, operator or system considers when validating a plan varies.  Different variables might be considered depending on the level of detail of the plan or stage in the overall planning process.  The scope and meaning of "valid" comes from context of the services, operator and systems creating the plan.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectPlanValidationCommand(
	pub crate::v2_5::types::EffectPlanValidationCommandMt,
);
impl Deref for EffectPlanValidationCommand {
	type Target = crate::v2_5::types::EffectPlanValidationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectPlanValidationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectPlanValidationCommandMt> for EffectPlanValidationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::EffectPlanValidationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectPlanValidationCommandMt> for EffectPlanValidationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectPlanValidationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectPlanValidationCommandMt> for EffectPlanValidationCommand {
	fn from(p: crate::v2_5::types::EffectPlanValidationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectPlanValidationCommandMt> for EffectPlanValidationCommand {
	fn into(self) -> crate::v2_5::types::EffectPlanValidationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to validate an EffectPlan, including the current state in a command and processing state machine.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectPlanValidationCommandStatus(
	pub crate::v2_5::types::EffectPlanValidationCommandStatusMt,
);
impl Deref for EffectPlanValidationCommandStatus {
	type Target = crate::v2_5::types::EffectPlanValidationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectPlanValidationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectPlanValidationCommandStatusMt> for EffectPlanValidationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EffectPlanValidationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectPlanValidationCommandStatusMt> for EffectPlanValidationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectPlanValidationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectPlanValidationCommandStatusMt> for EffectPlanValidationCommandStatus {
	fn from(p: crate::v2_5::types::EffectPlanValidationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectPlanValidationCommandStatusMt> for EffectPlanValidationCommandStatus {
	fn into(self) -> crate::v2_5::types::EffectPlanValidationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message defines planning status of a single Effect.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectPlanningStatus(
	pub crate::v2_5::types::EffectPlanningStatusMt,
);
impl Deref for EffectPlanningStatus {
	type Target = crate::v2_5::types::EffectPlanningStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectPlanningStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectPlanningStatusMt> for EffectPlanningStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EffectPlanningStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectPlanningStatusMt> for EffectPlanningStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectPlanningStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectPlanningStatusMt> for EffectPlanningStatus {
	fn from(p: crate::v2_5::types::EffectPlanningStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectPlanningStatusMt> for EffectPlanningStatus {
	fn into(self) -> crate::v2_5::types::EffectPlanningStatusMt {
		self.0
	}
}


#[doc = r#"Indicates the execution status for an Effect.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EffectStatus(
	pub crate::v2_5::types::EffectStatusMt,
);
impl Deref for EffectStatus {
	type Target = crate::v2_5::types::EffectStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EffectStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EffectStatusMt> for EffectStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EffectStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EffectStatusMt> for EffectStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EffectStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EffectStatusMt> for EffectStatus {
	fn from(p: crate::v2_5::types::EffectStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EffectStatusMt> for EffectStatus {
	fn into(self) -> crate::v2_5::types::EffectStatusMt {
		self.0
	}
}


#[doc = r#"This message is to request the elevation of a list of points.  Elevation data can come from different sources such as Digital Terrain Elevation Data (DTED), Global Digital Elevation Map (GDEM), mensuration tools, or operator input.  Although DTED is the most widely used there could be other elevation sources hence the use of term elevation.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ElevationRequest(
	pub crate::v2_5::types::ElevationRequestMt,
);
impl Deref for ElevationRequest {
	type Target = crate::v2_5::types::ElevationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ElevationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ElevationRequestMt> for ElevationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ElevationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ElevationRequestMt> for ElevationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ElevationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ElevationRequestMt> for ElevationRequest {
	fn from(p: crate::v2_5::types::ElevationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ElevationRequestMt> for ElevationRequest {
	fn into(self) -> crate::v2_5::types::ElevationRequestMt {
		self.0
	}
}


#[doc = r#"This message contains the response to an ElevationRequest with list of points in same order with elevation field filled in when possible.  Elevation data can come from different sources such as Digital Terrain Elevation Data (DTED), Global Digital Elevation Map (GDEM), mensuration tools, or operator input.  Although DTED is the most widely used there could be other elevation sources hence the use of term elevation.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ElevationRequestStatus(
	pub crate::v2_5::types::ElevationRequestStatusMt,
);
impl Deref for ElevationRequestStatus {
	type Target = crate::v2_5::types::ElevationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ElevationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ElevationRequestStatusMt> for ElevationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ElevationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ElevationRequestStatusMt> for ElevationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ElevationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ElevationRequestStatusMt> for ElevationRequestStatus {
	fn from(p: crate::v2_5::types::ElevationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ElevationRequestStatusMt> for ElevationRequestStatus {
	fn into(self) -> crate::v2_5::types::ElevationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message contains a request for the visibility from a given point (FromPoint) to a list of points (VisibilityPoint); i.e. which points in the list are visible to the FromPoint.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ElevationVisibilityRequest(
	pub crate::v2_5::types::ElevationVisibilityRequestMt,
);
impl Deref for ElevationVisibilityRequest {
	type Target = crate::v2_5::types::ElevationVisibilityRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ElevationVisibilityRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ElevationVisibilityRequestMt> for ElevationVisibilityRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ElevationVisibilityRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ElevationVisibilityRequestMt> for ElevationVisibilityRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ElevationVisibilityRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ElevationVisibilityRequestMt> for ElevationVisibilityRequest {
	fn from(p: crate::v2_5::types::ElevationVisibilityRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ElevationVisibilityRequestMt> for ElevationVisibilityRequest {
	fn into(self) -> crate::v2_5::types::ElevationVisibilityRequestMt {
		self.0
	}
}


#[doc = r#"This message contains the response to an ElevationVisibilityRequest message.  The response list indicates request point visibility with respect to the request FromPoint.  The response visibility data list is in the same order as the requesting point list.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ElevationVisibilityRequestStatus(
	pub crate::v2_5::types::ElevationVisibilityRequestStatusMt,
);
impl Deref for ElevationVisibilityRequestStatus {
	type Target = crate::v2_5::types::ElevationVisibilityRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ElevationVisibilityRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ElevationVisibilityRequestStatusMt> for ElevationVisibilityRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ElevationVisibilityRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ElevationVisibilityRequestStatusMt> for ElevationVisibilityRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ElevationVisibilityRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ElevationVisibilityRequestStatusMt> for ElevationVisibilityRequestStatus {
	fn from(p: crate::v2_5::types::ElevationVisibilityRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ElevationVisibilityRequestStatusMt> for ElevationVisibilityRequestStatus {
	fn into(self) -> crate::v2_5::types::ElevationVisibilityRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message contains a representation of an Emitter Record within an Order of Battle.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EmitterRecord(
	pub crate::v2_5::types::EmitterRecordMt,
);
impl Deref for EmitterRecord {
	type Target = crate::v2_5::types::EmitterRecordMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EmitterRecord {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EmitterRecordMt> for EmitterRecord {
	fn as_ref(&self) -> &crate::v2_5::types::EmitterRecordMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EmitterRecordMt> for EmitterRecord {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EmitterRecordMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EmitterRecordMt> for EmitterRecord {
	fn from(p: crate::v2_5::types::EmitterRecordMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EmitterRecordMt> for EmitterRecord {
	fn into(self) -> crate::v2_5::types::EmitterRecordMt {
		self.0
	}
}


#[doc = r#"This message represents an object (vehicle, weapon, person, building, etc.) in the battlespace.  This message can represent blue players that are non-taskable UCI participants.  Its structure is applicable to both blue force and red force objects.  An Entity can be anything from a pre-briefed, Order of Battle object derived from HUMINT to an actively tracked object fused from one or more dynamically tasked sensors.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Entity(
	pub crate::v2_5::types::EntityMt,
);
impl Deref for Entity {
	type Target = crate::v2_5::types::EntityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Entity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityMt> for Entity {
	fn as_ref(&self) -> &crate::v2_5::types::EntityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityMt> for Entity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityMt> for Entity {
	fn from(p: crate::v2_5::types::EntityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityMt> for Entity {
	fn into(self) -> crate::v2_5::types::EntityMt {
		self.0
	}
}


#[doc = r#"This message is used to confirm the Executing/Tactical System is observing the correct Entity by providing a Confirmation Probability or Confirmation Confidence Interval.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityConfirmation(
	pub crate::v2_5::types::EntityConfirmationMt,
);
impl Deref for EntityConfirmation {
	type Target = crate::v2_5::types::EntityConfirmationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityConfirmation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityConfirmationMt> for EntityConfirmation {
	fn as_ref(&self) -> &crate::v2_5::types::EntityConfirmationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityConfirmationMt> for EntityConfirmation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityConfirmationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityConfirmationMt> for EntityConfirmation {
	fn from(p: crate::v2_5::types::EntityConfirmationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityConfirmationMt> for EntityConfirmation {
	fn into(self) -> crate::v2_5::types::EntityConfirmationMt {
		self.0
	}
}


#[doc = r#"This information will be used to confirm the Executing/Tactical System is observing the correct Entity.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityConfirmationRequest(
	pub crate::v2_5::types::EntityConfirmationRequestMt,
);
impl Deref for EntityConfirmationRequest {
	type Target = crate::v2_5::types::EntityConfirmationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityConfirmationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityConfirmationRequestMt> for EntityConfirmationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::EntityConfirmationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityConfirmationRequestMt> for EntityConfirmationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityConfirmationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityConfirmationRequestMt> for EntityConfirmationRequest {
	fn from(p: crate::v2_5::types::EntityConfirmationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityConfirmationRequestMt> for EntityConfirmationRequest {
	fn into(self) -> crate::v2_5::types::EntityConfirmationRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to an EntityConfirmationRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityConfirmationRequestStatus(
	pub crate::v2_5::types::EntityConfirmationRequestStatusMt,
);
impl Deref for EntityConfirmationRequestStatus {
	type Target = crate::v2_5::types::EntityConfirmationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityConfirmationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityConfirmationRequestStatusMt> for EntityConfirmationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EntityConfirmationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityConfirmationRequestStatusMt> for EntityConfirmationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityConfirmationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityConfirmationRequestStatusMt> for EntityConfirmationRequestStatus {
	fn from(p: crate::v2_5::types::EntityConfirmationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityConfirmationRequestStatusMt> for EntityConfirmationRequestStatus {
	fn into(self) -> crate::v2_5::types::EntityConfirmationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message contains information identifying an Entity that was not observed in the time frame and location expected.  In Space operations, a Resident Space Object (RSO) entity is considered "lost" if it does not have any associated metric observations within the last 30 days. Other Entity-related messages characterize an Entity at a point in time based on an observation or propagation/prediction.  In contrast, this message indicates  a previously established Entity wasn't observed as expected/planned along with metrics characterizing the loss. For example, if several sensors are tracking an Entity and one sensor "loses" the Entity, this message would provide those details. This message could be provided directly by an observing System that produces other Entity* messages, by a Service that analyzes Entity* messages from other Systems over time, etc. This message applies to any object that is being observed by a sensor suite (including blue, red, and gray objects). This message also provides the details of an event occurring after enough data has been gathered to create this message.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityLost(
	pub crate::v2_5::types::EntityLostMt,
);
impl Deref for EntityLost {
	type Target = crate::v2_5::types::EntityLostMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityLost {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityLostMt> for EntityLost {
	fn as_ref(&self) -> &crate::v2_5::types::EntityLostMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityLostMt> for EntityLost {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityLostMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityLostMt> for EntityLost {
	fn from(p: crate::v2_5::types::EntityLostMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityLostMt> for EntityLost {
	fn into(self) -> crate::v2_5::types::EntityLostMt {
		self.0
	}
}


#[doc = r#"Indicates a request for an Entity management function such as fusion control.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityManagementRequest(
	pub crate::v2_5::types::EntityManagementRequestMt,
);
impl Deref for EntityManagementRequest {
	type Target = crate::v2_5::types::EntityManagementRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityManagementRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityManagementRequestMt> for EntityManagementRequest {
	fn as_ref(&self) -> &crate::v2_5::types::EntityManagementRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityManagementRequestMt> for EntityManagementRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityManagementRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityManagementRequestMt> for EntityManagementRequest {
	fn from(p: crate::v2_5::types::EntityManagementRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityManagementRequestMt> for EntityManagementRequest {
	fn into(self) -> crate::v2_5::types::EntityManagementRequestMt {
		self.0
	}
}


#[doc = r#"An Entity Management Request status is used by a service to report status/state of an EntityManagementRequest.  Since an EntityManagementRequest can be applied across systems and services, an EntityManagementRequest may result in generation of many status messages.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityManagementRequestStatus(
	pub crate::v2_5::types::EntityManagementRequestStatusMt,
);
impl Deref for EntityManagementRequestStatus {
	type Target = crate::v2_5::types::EntityManagementRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityManagementRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityManagementRequestStatusMt> for EntityManagementRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EntityManagementRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityManagementRequestStatusMt> for EntityManagementRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityManagementRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityManagementRequestStatusMt> for EntityManagementRequestStatus {
	fn from(p: crate::v2_5::types::EntityManagementRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityManagementRequestStatusMt> for EntityManagementRequestStatus {
	fn into(self) -> crate::v2_5::types::EntityManagementRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies supplemental data for Entities.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityMetadata(
	pub crate::v2_5::types::EntityMetadataMt,
);
impl Deref for EntityMetadata {
	type Target = crate::v2_5::types::EntityMetadataMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityMetadata {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityMetadataMt> for EntityMetadata {
	fn as_ref(&self) -> &crate::v2_5::types::EntityMetadataMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityMetadataMt> for EntityMetadata {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityMetadataMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityMetadataMt> for EntityMetadata {
	fn from(p: crate::v2_5::types::EntityMetadataMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityMetadataMt> for EntityMetadata {
	fn into(self) -> crate::v2_5::types::EntityMetadataMt {
		self.0
	}
}


#[doc = r#"This message contains a notification related to an Entity.  There are endless possible events, states, state changes and behaviors of Entities to monitor/observe.  In lieu of enumerating them all, this message categorizes them into "perspectives" such as kinematics, weather, and identity.  The message includes characteristics such as the Subject's ID, the perspective of the Subject, a message associated with the notification, and the parameters from NotificationBaseType.  For example, a weather monitoring Service could produce an EntityNotification message advising that a particular Entity is entering an area with potential weather hazards.  This message optionally references other messages that triggered or are related to the notification.  For example, an EntityNotification with a weather perspective could reference a WeatherDataset message with detailed weather data.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityNotification(
	pub crate::v2_5::types::EntityNotificationMt,
);
impl Deref for EntityNotification {
	type Target = crate::v2_5::types::EntityNotificationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityNotification {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityNotificationMt> for EntityNotification {
	fn as_ref(&self) -> &crate::v2_5::types::EntityNotificationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityNotificationMt> for EntityNotification {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityNotificationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityNotificationMt> for EntityNotification {
	fn from(p: crate::v2_5::types::EntityNotificationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityNotificationMt> for EntityNotification {
	fn into(self) -> crate::v2_5::types::EntityNotificationMt {
		self.0
	}
}


#[doc = r#"This messages represents closely-space operations (CSO) of orbiting entities, observed and characterized over a period of time including behavioral details beyond basic kinematics. This message applies to any object that is being observed by a sensor suite (including blue, red, and gray objects).UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityOrbitalCso(
	pub crate::v2_5::types::EntityOrbitalCsoMt,
);
impl Deref for EntityOrbitalCso {
	type Target = crate::v2_5::types::EntityOrbitalCsoMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityOrbitalCso {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityOrbitalCsoMt> for EntityOrbitalCso {
	fn as_ref(&self) -> &crate::v2_5::types::EntityOrbitalCsoMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityOrbitalCsoMt> for EntityOrbitalCso {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityOrbitalCsoMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityOrbitalCsoMt> for EntityOrbitalCso {
	fn from(p: crate::v2_5::types::EntityOrbitalCsoMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityOrbitalCsoMt> for EntityOrbitalCso {
	fn into(self) -> crate::v2_5::types::EntityOrbitalCsoMt {
		self.0
	}
}


#[doc = r#"This message represents what is commonly referred to as the two line element (TLE) for an Entity in orbit around Earth.  It describes a satellite's orbit kinematics using general perturbations theory (SGP, SGP4, PPT3) and Keplerian elements.  An orbital element set (OES), or simply "el set", contains six classical orbital elements and a time element (epoch) which can be converted into position and velocity vectors to generate the geometry and motion of where the satellite is located and where it is going.  An OES is a refined collection of data, continually updated over the life of the satellite.  Single position kinematics, ephemeris and VCM for an Entity are given in other Entity* messages.  Placing Entity-related data into separate messages enables separate sources/services to report data for the same Entity instance.   For example, an identity fusion service could publish the base Entity message to establish the existence of a battlespace object and other kinematic fusion and/or kinematic propagation services could publish Entity kinematics at higher rates and in different reference frames without resending the base Entity data that did not change.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityOrbitalElementSet(
	pub crate::v2_5::types::EntityOrbitalElementSetMt,
);
impl Deref for EntityOrbitalElementSet {
	type Target = crate::v2_5::types::EntityOrbitalElementSetMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityOrbitalElementSet {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityOrbitalElementSetMt> for EntityOrbitalElementSet {
	fn as_ref(&self) -> &crate::v2_5::types::EntityOrbitalElementSetMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityOrbitalElementSetMt> for EntityOrbitalElementSet {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityOrbitalElementSetMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityOrbitalElementSetMt> for EntityOrbitalElementSet {
	fn from(p: crate::v2_5::types::EntityOrbitalElementSetMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityOrbitalElementSetMt> for EntityOrbitalElementSet {
	fn into(self) -> crate::v2_5::types::EntityOrbitalElementSetMt {
		self.0
	}
}


#[doc = r#"This message requests an orbital element set for one or more Entities, applicable for a particular time window.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityOrbitalElementSetRequest(
	pub crate::v2_5::types::EntityOrbitalElementSetRequestMt,
);
impl Deref for EntityOrbitalElementSetRequest {
	type Target = crate::v2_5::types::EntityOrbitalElementSetRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityOrbitalElementSetRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityOrbitalElementSetRequestMt> for EntityOrbitalElementSetRequest {
	fn as_ref(&self) -> &crate::v2_5::types::EntityOrbitalElementSetRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityOrbitalElementSetRequestMt> for EntityOrbitalElementSetRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityOrbitalElementSetRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityOrbitalElementSetRequestMt> for EntityOrbitalElementSetRequest {
	fn from(p: crate::v2_5::types::EntityOrbitalElementSetRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityOrbitalElementSetRequestMt> for EntityOrbitalElementSetRequest {
	fn into(self) -> crate::v2_5::types::EntityOrbitalElementSetRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to an EntityOrbitalElementSetRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityOrbitalElementSetRequestStatus(
	pub crate::v2_5::types::EntityOrbitalElementSetRequestStatusMt,
);
impl Deref for EntityOrbitalElementSetRequestStatus {
	type Target = crate::v2_5::types::EntityOrbitalElementSetRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityOrbitalElementSetRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityOrbitalElementSetRequestStatusMt> for EntityOrbitalElementSetRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EntityOrbitalElementSetRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityOrbitalElementSetRequestStatusMt> for EntityOrbitalElementSetRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityOrbitalElementSetRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityOrbitalElementSetRequestStatusMt> for EntityOrbitalElementSetRequestStatus {
	fn from(p: crate::v2_5::types::EntityOrbitalElementSetRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityOrbitalElementSetRequestStatusMt> for EntityOrbitalElementSetRequestStatus {
	fn into(self) -> crate::v2_5::types::EntityOrbitalElementSetRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message represents ephemeris for an Entity in the form of a series of predicted or actual kinematic positions and velocities of a satellite in an orderly sequence of time points (may be created at fixed or variable time spacing). Optionally includes covariance matrices that contains information about the uncertainties associated with the solution of the element corrections.  Single position kinematics, TLE and VCM for an Entity are given in other Entity* messages.  Placing Entity related data into separate messages enables multiple sources/Services to report data for the same Entity instance.  For example, an identity fusion service could publish the base Entity message to establish the existence of a battlespace object and other kinematic fusion and/or kinematic propagation services could publish Entity kinematics at higher rates and in different reference frames without resending the base Entity data that did not change.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityOrbitalEphemeris(
	pub crate::v2_5::types::EntityOrbitalEphemerisMt,
);
impl Deref for EntityOrbitalEphemeris {
	type Target = crate::v2_5::types::EntityOrbitalEphemerisMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityOrbitalEphemeris {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityOrbitalEphemerisMt> for EntityOrbitalEphemeris {
	fn as_ref(&self) -> &crate::v2_5::types::EntityOrbitalEphemerisMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityOrbitalEphemerisMt> for EntityOrbitalEphemeris {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityOrbitalEphemerisMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityOrbitalEphemerisMt> for EntityOrbitalEphemeris {
	fn from(p: crate::v2_5::types::EntityOrbitalEphemerisMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityOrbitalEphemerisMt> for EntityOrbitalEphemeris {
	fn into(self) -> crate::v2_5::types::EntityOrbitalEphemerisMt {
		self.0
	}
}


#[doc = r#"This message requests orbital ephemeris for one or more Entities, applicable for a particular time window.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityOrbitalEphemerisRequest(
	pub crate::v2_5::types::EntityOrbitalEphemerisRequestMt,
);
impl Deref for EntityOrbitalEphemerisRequest {
	type Target = crate::v2_5::types::EntityOrbitalEphemerisRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityOrbitalEphemerisRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityOrbitalEphemerisRequestMt> for EntityOrbitalEphemerisRequest {
	fn as_ref(&self) -> &crate::v2_5::types::EntityOrbitalEphemerisRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityOrbitalEphemerisRequestMt> for EntityOrbitalEphemerisRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityOrbitalEphemerisRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityOrbitalEphemerisRequestMt> for EntityOrbitalEphemerisRequest {
	fn from(p: crate::v2_5::types::EntityOrbitalEphemerisRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityOrbitalEphemerisRequestMt> for EntityOrbitalEphemerisRequest {
	fn into(self) -> crate::v2_5::types::EntityOrbitalEphemerisRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to an EntityOrbitalEphemerisRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityOrbitalEphemerisRequestStatus(
	pub crate::v2_5::types::EntityOrbitalEphemerisRequestStatusMt,
);
impl Deref for EntityOrbitalEphemerisRequestStatus {
	type Target = crate::v2_5::types::EntityOrbitalEphemerisRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityOrbitalEphemerisRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityOrbitalEphemerisRequestStatusMt> for EntityOrbitalEphemerisRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EntityOrbitalEphemerisRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityOrbitalEphemerisRequestStatusMt> for EntityOrbitalEphemerisRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityOrbitalEphemerisRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityOrbitalEphemerisRequestStatusMt> for EntityOrbitalEphemerisRequestStatus {
	fn from(p: crate::v2_5::types::EntityOrbitalEphemerisRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityOrbitalEphemerisRequestStatusMt> for EntityOrbitalEphemerisRequestStatus {
	fn into(self) -> crate::v2_5::types::EntityOrbitalEphemerisRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message represents maneuvers of orbiting entities, characterized over a period of time including behavioral details beyond basic kinematics. This includes indicating the details of the maneuver, even if the maneuver event is captured after it occurs. This message applies to any object that is being observed by a sensor suite (including blue, red, and gray objects).UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityOrbitalManeuver(
	pub crate::v2_5::types::EntityOrbitalManeuverMt,
);
impl Deref for EntityOrbitalManeuver {
	type Target = crate::v2_5::types::EntityOrbitalManeuverMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityOrbitalManeuver {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityOrbitalManeuverMt> for EntityOrbitalManeuver {
	fn as_ref(&self) -> &crate::v2_5::types::EntityOrbitalManeuverMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityOrbitalManeuverMt> for EntityOrbitalManeuver {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityOrbitalManeuverMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityOrbitalManeuverMt> for EntityOrbitalManeuver {
	fn from(p: crate::v2_5::types::EntityOrbitalManeuverMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityOrbitalManeuverMt> for EntityOrbitalManeuver {
	fn into(self) -> crate::v2_5::types::EntityOrbitalManeuverMt {
		self.0
	}
}


#[doc = r#"This message represents a "vector covariance matrix" or VCM which is a specialized state vector, along with extensive propagation parameters, tailored specifically for customers who are using an ASW system to propagate the vector.  A VCM should not be confused with the simpler and more common kinematic variance for position-position or position-velocity.  The VCM has all the additional information needed to correctly propagate the vector using the Special Perturbations Ephemeris Generator in ASW. The VCM includes a covariance matrix that provides the epoch covariance in equinoctial elements and only provides UVW variances.  Single position kinematics, TLE and ephemeris for an Entity are given in other Entity* messages.  Placing Entity related data into separate messages enables multiple sources/Services to report data for the same Entity instance.   For example, an identity fusion service could publish the base Entity message to establish the existence of a battlespace object and other kinematic fusion and/or kinematic propagation services could publish Entity kinematics at higher rates and in different reference frames without resending the base Entity data that did not change.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityOrbitalVcm(
	pub crate::v2_5::types::EntityOrbitalVcmMt,
);
impl Deref for EntityOrbitalVcm {
	type Target = crate::v2_5::types::EntityOrbitalVcmMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityOrbitalVcm {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityOrbitalVcmMt> for EntityOrbitalVcm {
	fn as_ref(&self) -> &crate::v2_5::types::EntityOrbitalVcmMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityOrbitalVcmMt> for EntityOrbitalVcm {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityOrbitalVcmMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityOrbitalVcmMt> for EntityOrbitalVcm {
	fn from(p: crate::v2_5::types::EntityOrbitalVcmMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityOrbitalVcmMt> for EntityOrbitalVcm {
	fn into(self) -> crate::v2_5::types::EntityOrbitalVcmMt {
		self.0
	}
}


#[doc = r#"This message requests an orbital Vector Covariance Matrix (VCM) for an Entity that is in orbit.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityOrbitalVcmRequest(
	pub crate::v2_5::types::EntityOrbitalVcmRequestMt,
);
impl Deref for EntityOrbitalVcmRequest {
	type Target = crate::v2_5::types::EntityOrbitalVcmRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityOrbitalVcmRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityOrbitalVcmRequestMt> for EntityOrbitalVcmRequest {
	fn as_ref(&self) -> &crate::v2_5::types::EntityOrbitalVcmRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityOrbitalVcmRequestMt> for EntityOrbitalVcmRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityOrbitalVcmRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityOrbitalVcmRequestMt> for EntityOrbitalVcmRequest {
	fn from(p: crate::v2_5::types::EntityOrbitalVcmRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityOrbitalVcmRequestMt> for EntityOrbitalVcmRequest {
	fn into(self) -> crate::v2_5::types::EntityOrbitalVcmRequestMt {
		self.0
	}
}


#[doc = r#"This message contains the response to an EntityOrbitalVCM_Request message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityOrbitalVcmRequestStatus(
	pub crate::v2_5::types::EntityOrbitalVcmRequestStatusMt,
);
impl Deref for EntityOrbitalVcmRequestStatus {
	type Target = crate::v2_5::types::EntityOrbitalVcmRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityOrbitalVcmRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityOrbitalVcmRequestStatusMt> for EntityOrbitalVcmRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EntityOrbitalVcmRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityOrbitalVcmRequestStatusMt> for EntityOrbitalVcmRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityOrbitalVcmRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityOrbitalVcmRequestStatusMt> for EntityOrbitalVcmRequestStatus {
	fn from(p: crate::v2_5::types::EntityOrbitalVcmRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityOrbitalVcmRequestStatusMt> for EntityOrbitalVcmRequestStatus {
	fn into(self) -> crate::v2_5::types::EntityOrbitalVcmRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message represents the extrapolated position of an Entity (vehicle, weapon, person, building, etc.) in the battlespace.  This message only contains extrapolated kinematic information.  Additional non-kinematic characteristics of a given Entity can be found in other messages.  This message is applicable to Services (such as kinematic fusion) which extrapolate kinematics between updates from sensors or other sources contributing fusion inputs.  Entity kinematics updates that are a result of updates from contributing sources shouldn't be reported using this message.  This message doesn't have a ObjectState; the extrapolated Entities follow the ObjectState of their associated Entity message/object.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EntityPropagation(
	pub crate::v2_5::types::EntityPropagationMt,
);
impl Deref for EntityPropagation {
	type Target = crate::v2_5::types::EntityPropagationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EntityPropagation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EntityPropagationMt> for EntityPropagation {
	fn as_ref(&self) -> &crate::v2_5::types::EntityPropagationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EntityPropagationMt> for EntityPropagation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EntityPropagationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EntityPropagationMt> for EntityPropagation {
	fn from(p: crate::v2_5::types::EntityPropagationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EntityPropagationMt> for EntityPropagation {
	fn into(self) -> crate::v2_5::types::EntityPropagationMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the ESM Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (ESM_Command) from an Operator or Capability management Service, 3) currently in-work ESM, 4) ESM scheduled for the future and 5) ESM that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single ESM_Command or other triggering event can result in multiple activities within the ESM_Activity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EsmActivity(
	pub crate::v2_5::types::EsmActivityMt,
);
impl Deref for EsmActivity {
	type Target = crate::v2_5::types::EsmActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EsmActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EsmActivityMt> for EsmActivity {
	fn as_ref(&self) -> &crate::v2_5::types::EsmActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EsmActivityMt> for EsmActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EsmActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EsmActivityMt> for EsmActivity {
	fn from(p: crate::v2_5::types::EsmActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EsmActivityMt> for EsmActivity {
	fn into(self) -> crate::v2_5::types::EsmActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the Electronic Support Measure (ESM) category of UCI Capability. This message "advertises" the mostly static characteristics of a mission-ready ESM Capability (of a Subsystem of System) so that it can be "discovered" and used. "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities. They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control. In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services. A [Capability]Capability message describes what a Subsystem is capable of doing if invoked. A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others. Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages. Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EsmCapability(
	pub crate::v2_5::types::EsmCapabilityMt,
);
impl Deref for EsmCapability {
	type Target = crate::v2_5::types::EsmCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EsmCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EsmCapabilityMt> for EsmCapability {
	fn as_ref(&self) -> &crate::v2_5::types::EsmCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EsmCapabilityMt> for EsmCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EsmCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EsmCapabilityMt> for EsmCapability {
	fn from(p: crate::v2_5::types::EsmCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EsmCapabilityMt> for EsmCapability {
	fn into(self) -> crate::v2_5::types::EsmCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the ESM (Electronic Support Measures) capabilities available to the system as advertised in the ESM_Capability message.  This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EsmCapabilityStatus(
	pub crate::v2_5::types::EsmCapabilityStatusMt,
);
impl Deref for EsmCapabilityStatus {
	type Target = crate::v2_5::types::EsmCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EsmCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EsmCapabilityStatusMt> for EsmCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EsmCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EsmCapabilityStatusMt> for EsmCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EsmCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EsmCapabilityStatusMt> for EsmCapabilityStatus {
	fn from(p: crate::v2_5::types::EsmCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EsmCapabilityStatusMt> for EsmCapabilityStatus {
	fn into(self) -> crate::v2_5::types::EsmCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the ESM (Electronic Support Measures) form of the general UCI Capability Command.  It is used to manually invoke an ESM Capability to perform a new ESM Activity or change an existing interactive ESM Activity.  It differs from an ESM Task because it is intended for direct interaction with the host of the Capability, not a planning Service, and therefore is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan.  Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages.  Capability Commands can be used in parallel with Tasks, but are generally deferential to them.  However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EsmCommand(
	pub crate::v2_5::types::EsmCommandMt,
);
impl Deref for EsmCommand {
	type Target = crate::v2_5::types::EsmCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EsmCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EsmCommandMt> for EsmCommand {
	fn as_ref(&self) -> &crate::v2_5::types::EsmCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EsmCommandMt> for EsmCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EsmCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EsmCommandMt> for EsmCommand {
	fn from(p: crate::v2_5::types::EsmCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EsmCommandMt> for EsmCommand {
	fn into(self) -> crate::v2_5::types::EsmCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an ESM_Command.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the ESM_Activity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EsmCommandStatus(
	pub crate::v2_5::types::EsmCommandStatusMt,
);
impl Deref for EsmCommandStatus {
	type Target = crate::v2_5::types::EsmCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EsmCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EsmCommandStatusMt> for EsmCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EsmCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EsmCommandStatusMt> for EsmCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EsmCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EsmCommandStatusMt> for EsmCommandStatus {
	fn from(p: crate::v2_5::types::EsmCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EsmCommandStatusMt> for EsmCommandStatus {
	fn into(self) -> crate::v2_5::types::EsmCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to request consent to perform ESM.  Status for this command message is provided via the ESM_ConsentRequestStatus message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EsmConsentRequest(
	pub crate::v2_5::types::EsmConsentRequestMt,
);
impl Deref for EsmConsentRequest {
	type Target = crate::v2_5::types::EsmConsentRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EsmConsentRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EsmConsentRequestMt> for EsmConsentRequest {
	fn as_ref(&self) -> &crate::v2_5::types::EsmConsentRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EsmConsentRequestMt> for EsmConsentRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EsmConsentRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EsmConsentRequestMt> for EsmConsentRequest {
	fn from(p: crate::v2_5::types::EsmConsentRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EsmConsentRequestMt> for EsmConsentRequest {
	fn into(self) -> crate::v2_5::types::EsmConsentRequestMt {
		self.0
	}
}


#[doc = r#"This message is used to report consent request status for its corresponding ESM_ConsentRequest message used to perform Electronic Support Measures (ESM) capabilities.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EsmConsentRequestStatus(
	pub crate::v2_5::types::EsmConsentRequestStatusMt,
);
impl Deref for EsmConsentRequestStatus {
	type Target = crate::v2_5::types::EsmConsentRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EsmConsentRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EsmConsentRequestStatusMt> for EsmConsentRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EsmConsentRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EsmConsentRequestStatusMt> for EsmConsentRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EsmConsentRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EsmConsentRequestStatusMt> for EsmConsentRequestStatus {
	fn from(p: crate::v2_5::types::EsmConsentRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EsmConsentRequestStatusMt> for EsmConsentRequestStatus {
	fn into(self) -> crate::v2_5::types::EsmConsentRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the ESM Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EsmSettingsCommand(
	pub crate::v2_5::types::EsmSettingsCommandMt,
);
impl Deref for EsmSettingsCommand {
	type Target = crate::v2_5::types::EsmSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EsmSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EsmSettingsCommandMt> for EsmSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::EsmSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EsmSettingsCommandMt> for EsmSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EsmSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EsmSettingsCommandMt> for EsmSettingsCommand {
	fn from(p: crate::v2_5::types::EsmSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EsmSettingsCommandMt> for EsmSettingsCommand {
	fn into(self) -> crate::v2_5::types::EsmSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message is used to report settings status for its corresponding ESM_SettingsCommand message used to change the settings associated with known Electronic Support Measures (ESM) capabilities.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EsmSettingsCommandStatus(
	pub crate::v2_5::types::EsmSettingsCommandStatusMt,
);
impl Deref for EsmSettingsCommandStatus {
	type Target = crate::v2_5::types::EsmSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EsmSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EsmSettingsCommandStatusMt> for EsmSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::EsmSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EsmSettingsCommandStatusMt> for EsmSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EsmSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EsmSettingsCommandStatusMt> for EsmSettingsCommandStatus {
	fn from(p: crate::v2_5::types::EsmSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EsmSettingsCommandStatusMt> for EsmSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::EsmSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to document the configuration settings of RF based subsystems such as ESM, EA, ELINT and COMINT.  These configuration settings can be used by a resource manager service to configure and match the subsystem capabilities  to the available RF Distribution and internal channel definitions.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct EwConfiguration(
	pub crate::v2_5::types::EwConfigurationMt,
);
impl Deref for EwConfiguration {
	type Target = crate::v2_5::types::EwConfigurationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for EwConfiguration {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::EwConfigurationMt> for EwConfiguration {
	fn as_ref(&self) -> &crate::v2_5::types::EwConfigurationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::EwConfigurationMt> for EwConfiguration {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::EwConfigurationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::EwConfigurationMt> for EwConfiguration {
	fn from(p: crate::v2_5::types::EwConfigurationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::EwConfigurationMt> for EwConfiguration {
	fn into(self) -> crate::v2_5::types::EwConfigurationMt {
		self.0
	}
}


#[doc = r#"This message is used to initiate the retrieval of data that has been updated/provided by an external/national database/source.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ExternalDataRequest(
	pub crate::v2_5::types::ExternalDataRequestMt,
);
impl Deref for ExternalDataRequest {
	type Target = crate::v2_5::types::ExternalDataRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ExternalDataRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ExternalDataRequestMt> for ExternalDataRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ExternalDataRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ExternalDataRequestMt> for ExternalDataRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ExternalDataRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ExternalDataRequestMt> for ExternalDataRequest {
	fn from(p: crate::v2_5::types::ExternalDataRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ExternalDataRequestMt> for ExternalDataRequest {
	fn into(self) -> crate::v2_5::types::ExternalDataRequestMt {
		self.0
	}
}


#[doc = r#"This message is to report status/state of an ExternalDataRequest.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ExternalDataRequestStatus(
	pub crate::v2_5::types::ExternalDataRequestStatusMt,
);
impl Deref for ExternalDataRequestStatus {
	type Target = crate::v2_5::types::ExternalDataRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ExternalDataRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ExternalDataRequestStatusMt> for ExternalDataRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ExternalDataRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ExternalDataRequestStatusMt> for ExternalDataRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ExternalDataRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ExternalDataRequestStatusMt> for ExternalDataRequestStatus {
	fn from(p: crate::v2_5::types::ExternalDataRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ExternalDataRequestStatusMt> for ExternalDataRequestStatus {
	fn into(self) -> crate::v2_5::types::ExternalDataRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message contains a representation of a Facility (a.k.a Site) Record within an Order of Battle.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct FacilityRecord(
	pub crate::v2_5::types::FacilityRecordMt,
);
impl Deref for FacilityRecord {
	type Target = crate::v2_5::types::FacilityRecordMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for FacilityRecord {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::FacilityRecordMt> for FacilityRecord {
	fn as_ref(&self) -> &crate::v2_5::types::FacilityRecordMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::FacilityRecordMt> for FacilityRecord {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::FacilityRecordMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::FacilityRecordMt> for FacilityRecord {
	fn from(p: crate::v2_5::types::FacilityRecordMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::FacilityRecordMt> for FacilityRecord {
	fn into(self) -> crate::v2_5::types::FacilityRecordMt {
		self.0
	}
}


#[doc = r#"This represents a fault for the system.  Intended to be used by services such as a health monitoring service for centralized fault management and fault isolation of a system.  Allows announcing a fault state change (raised or cleared) from a service as opposed to a capability or component of a subsystem.  Also conveys a service relationship in addition to a subsystem relationship.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Fault(
	pub crate::v2_5::types::FaultMt,
);
impl Deref for Fault {
	type Target = crate::v2_5::types::FaultMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Fault {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::FaultMt> for Fault {
	fn as_ref(&self) -> &crate::v2_5::types::FaultMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::FaultMt> for Fault {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::FaultMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::FaultMt> for Fault {
	fn from(p: crate::v2_5::types::FaultMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::FaultMt> for Fault {
	fn into(self) -> crate::v2_5::types::FaultMt {
		self.0
	}
}


#[doc = r#"This message specifies the network location of a file.  See the annotations for FileMetadata for an explanation of how it works together with this message.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct FileLocation(
	pub crate::v2_5::types::FileLocationMt,
);
impl Deref for FileLocation {
	type Target = crate::v2_5::types::FileLocationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for FileLocation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::FileLocationMt> for FileLocation {
	fn as_ref(&self) -> &crate::v2_5::types::FileLocationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::FileLocationMt> for FileLocation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::FileLocationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::FileLocationMt> for FileLocation {
	fn from(p: crate::v2_5::types::FileLocationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::FileLocationMt> for FileLocation {
	fn into(self) -> crate::v2_5::types::FileLocationMt {
		self.0
	}
}


#[doc = r#"This message specifies UCI relevant metadata for a File.  A File is an item that isn't a Product, whose content and format are specified outside of the UCI standard.  It does not contain actual file contents nor does it specify their network location.  Network location is published in the FileLocation message.  "Metadata" includes a summary of the content type, classification, file name, file format and other characteristics of the file.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct FileMetadata(
	pub crate::v2_5::types::FileMetadataMt,
);
impl Deref for FileMetadata {
	type Target = crate::v2_5::types::FileMetadataMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for FileMetadata {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::FileMetadataMt> for FileMetadata {
	fn as_ref(&self) -> &crate::v2_5::types::FileMetadataMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::FileMetadataMt> for FileMetadata {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::FileMetadataMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::FileMetadataMt> for FileMetadata {
	fn from(p: crate::v2_5::types::FileMetadataMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::FileMetadataMt> for FileMetadata {
	fn into(self) -> crate::v2_5::types::FileMetadataMt {
		self.0
	}
}


#[doc = r#"A [Capability]Activity message describes what a Capability is actively doing  It is generally a complete, coherent snapshot of all Activities for a Capability category (ESM, EA, etc.). In UCI terminology, an Activity is the dynamic, per-use status of a Capability. An Activity is an abstraction that includes the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct FlightActivity(
	pub crate::v2_5::types::FlightActivityMt,
);
impl Deref for FlightActivity {
	type Target = crate::v2_5::types::FlightActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for FlightActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::FlightActivityMt> for FlightActivity {
	fn as_ref(&self) -> &crate::v2_5::types::FlightActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::FlightActivityMt> for FlightActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::FlightActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::FlightActivityMt> for FlightActivity {
	fn from(p: crate::v2_5::types::FlightActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::FlightActivityMt> for FlightActivity {
	fn into(self) -> crate::v2_5::types::FlightActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the Flight category of UCI Capability.  It "advertises" the mostly static characteristics of a mission-ready Flight Capability so that it can be "discovered" and used. "Discovery" can be a misnomer depending on your perspective. UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities. They don't eliminate the need for future software updates or configuration files. UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission. In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services. A [Capability]Capability message describes what a Subsystem is capable of doing if invoked. A [Capability]Activity message describes what a Capability is doing. Capabilities are aligned with end effects of Mission operations and for the Flight Capability, it could be a required route sequence, orbit/loiter point, etc.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct FlightCapability(
	pub crate::v2_5::types::FlightCapabilityMt,
);
impl Deref for FlightCapability {
	type Target = crate::v2_5::types::FlightCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for FlightCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::FlightCapabilityMt> for FlightCapability {
	fn as_ref(&self) -> &crate::v2_5::types::FlightCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::FlightCapabilityMt> for FlightCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::FlightCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::FlightCapabilityMt> for FlightCapability {
	fn from(p: crate::v2_5::types::FlightCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::FlightCapabilityMt> for FlightCapability {
	fn into(self) -> crate::v2_5::types::FlightCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Flight capabilities available to the system. This includes information regarding whether or not each capability is currently available based on hardware status, operational states, etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct FlightCapabilityStatus(
	pub crate::v2_5::types::FlightCapabilityStatusMt,
);
impl Deref for FlightCapabilityStatus {
	type Target = crate::v2_5::types::FlightCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for FlightCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::FlightCapabilityStatusMt> for FlightCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::FlightCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::FlightCapabilityStatusMt> for FlightCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::FlightCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::FlightCapabilityStatusMt> for FlightCapabilityStatus {
	fn from(p: crate::v2_5::types::FlightCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::FlightCapabilityStatusMt> for FlightCapabilityStatus {
	fn into(self) -> crate::v2_5::types::FlightCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message contains a list of ForeignKeyPair IDs that themselves specify IDs, within the domain of this schema, to be associated with a key, ID, etc. that exists in another system, protocol, network, etc.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ForeignKeyMap(
	pub crate::v2_5::types::ForeignKeyMapMt,
);
impl Deref for ForeignKeyMap {
	type Target = crate::v2_5::types::ForeignKeyMapMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ForeignKeyMap {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ForeignKeyMapMt> for ForeignKeyMap {
	fn as_ref(&self) -> &crate::v2_5::types::ForeignKeyMapMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ForeignKeyMapMt> for ForeignKeyMap {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ForeignKeyMapMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ForeignKeyMapMt> for ForeignKeyMap {
	fn from(p: crate::v2_5::types::ForeignKeyMapMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ForeignKeyMapMt> for ForeignKeyMap {
	fn into(self) -> crate::v2_5::types::ForeignKeyMapMt {
		self.0
	}
}


#[doc = r#"This message indicates a paired mapping of a Foreign Key to a Native ID.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ForeignKeyPair(
	pub crate::v2_5::types::ForeignKeyPairMt,
);
impl Deref for ForeignKeyPair {
	type Target = crate::v2_5::types::ForeignKeyPairMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ForeignKeyPair {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ForeignKeyPairMt> for ForeignKeyPair {
	fn as_ref(&self) -> &crate::v2_5::types::ForeignKeyPairMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ForeignKeyPairMt> for ForeignKeyPair {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ForeignKeyPairMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ForeignKeyPairMt> for ForeignKeyPair {
	fn from(p: crate::v2_5::types::ForeignKeyPairMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ForeignKeyPairMt> for ForeignKeyPair {
	fn into(self) -> crate::v2_5::types::ForeignKeyPairMt {
		self.0
	}
}


#[doc = r#"This message is utilized to capture the settings for Fusion services.  This message is a reflection of all settings resulting from all requests that are currently in effect for the specified service.  It is expected that fusion services manage their own settings and publish them on updates and/or in response to QueryDataRequest.  Fusion settings can be changed via FusionSettingsRequest.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct FusionSettings(
	pub crate::v2_5::types::FusionSettingsMt,
);
impl Deref for FusionSettings {
	type Target = crate::v2_5::types::FusionSettingsMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for FusionSettings {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::FusionSettingsMt> for FusionSettings {
	fn as_ref(&self) -> &crate::v2_5::types::FusionSettingsMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::FusionSettingsMt> for FusionSettings {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::FusionSettingsMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::FusionSettingsMt> for FusionSettings {
	fn from(p: crate::v2_5::types::FusionSettingsMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::FusionSettingsMt> for FusionSettings {
	fn into(self) -> crate::v2_5::types::FusionSettingsMt {
		self.0
	}
}


#[doc = r#"This message indicates a request to change settings for a Fusion Service.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct FusionSettingsRequest(
	pub crate::v2_5::types::FusionSettingsRequestMt,
);
impl Deref for FusionSettingsRequest {
	type Target = crate::v2_5::types::FusionSettingsRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for FusionSettingsRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::FusionSettingsRequestMt> for FusionSettingsRequest {
	fn as_ref(&self) -> &crate::v2_5::types::FusionSettingsRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::FusionSettingsRequestMt> for FusionSettingsRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::FusionSettingsRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::FusionSettingsRequestMt> for FusionSettingsRequest {
	fn from(p: crate::v2_5::types::FusionSettingsRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::FusionSettingsRequestMt> for FusionSettingsRequest {
	fn into(self) -> crate::v2_5::types::FusionSettingsRequestMt {
		self.0
	}
}


#[doc = r#"This message is used by a Fusion service to report status/state of a FusionSettingsRequest.  Since a FusionSettingsRequest can be applied across systems and services, it may result in status messages from each.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct FusionSettingsRequestStatus(
	pub crate::v2_5::types::FusionSettingsRequestStatusMt,
);
impl Deref for FusionSettingsRequestStatus {
	type Target = crate::v2_5::types::FusionSettingsRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for FusionSettingsRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::FusionSettingsRequestStatusMt> for FusionSettingsRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::FusionSettingsRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::FusionSettingsRequestStatusMt> for FusionSettingsRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::FusionSettingsRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::FusionSettingsRequestStatusMt> for FusionSettingsRequestStatus {
	fn from(p: crate::v2_5::types::FusionSettingsRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::FusionSettingsRequestStatusMt> for FusionSettingsRequestStatus {
	fn into(self) -> crate::v2_5::types::FusionSettingsRequestStatusMt {
		self.0
	}
}


#[doc = r#"A [Capability]Activity message describes what a Capability is actively doing. It is generally a complete, coherent snapshot of all Activities for a Capability Category (ESM, EA, etc.). In UCI terminology, an Activity is the dynamic, per-use status of a Capability. An Activity is an abstraction that includes the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct GatewayActivity(
	pub crate::v2_5::types::GatewayActivityMt,
);
impl Deref for GatewayActivity {
	type Target = crate::v2_5::types::GatewayActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for GatewayActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::GatewayActivityMt> for GatewayActivity {
	fn as_ref(&self) -> &crate::v2_5::types::GatewayActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::GatewayActivityMt> for GatewayActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::GatewayActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::GatewayActivityMt> for GatewayActivity {
	fn from(p: crate::v2_5::types::GatewayActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::GatewayActivityMt> for GatewayActivity {
	fn into(self) -> crate::v2_5::types::GatewayActivityMt {
		self.0
	}
}


#[doc = r#"A Gateway Capability message describes what a Gateway Subsystem is capable of doing if invoked.  The capabilities include Gateway data processor instantiation/tear-down, etc. settings provided by the Gateway.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct GatewayCapability(
	pub crate::v2_5::types::GatewayCapabilityMt,
);
impl Deref for GatewayCapability {
	type Target = crate::v2_5::types::GatewayCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for GatewayCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::GatewayCapabilityMt> for GatewayCapability {
	fn as_ref(&self) -> &crate::v2_5::types::GatewayCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::GatewayCapabilityMt> for GatewayCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::GatewayCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::GatewayCapabilityMt> for GatewayCapability {
	fn from(p: crate::v2_5::types::GatewayCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::GatewayCapabilityMt> for GatewayCapability {
	fn into(self) -> crate::v2_5::types::GatewayCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Data Processor capabilities available to the system.   This includes information regarding whether or not each capability is currently available, commanded operational states, associated Data Processor profiles etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct GatewayCapabilityStatus(
	pub crate::v2_5::types::GatewayCapabilityStatusMt,
);
impl Deref for GatewayCapabilityStatus {
	type Target = crate::v2_5::types::GatewayCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for GatewayCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::GatewayCapabilityStatusMt> for GatewayCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::GatewayCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::GatewayCapabilityStatusMt> for GatewayCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::GatewayCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::GatewayCapabilityStatusMt> for GatewayCapabilityStatus {
	fn from(p: crate::v2_5::types::GatewayCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::GatewayCapabilityStatusMt> for GatewayCapabilityStatus {
	fn into(self) -> crate::v2_5::types::GatewayCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is a derivation of the UCI Capability command.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and Data Processor commands including Capability precedence, Task rank, Data Processor command rank, Data Processor Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct GatewayCommand(
	pub crate::v2_5::types::GatewayCommandMt,
);
impl Deref for GatewayCommand {
	type Target = crate::v2_5::types::GatewayCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for GatewayCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::GatewayCommandMt> for GatewayCommand {
	fn as_ref(&self) -> &crate::v2_5::types::GatewayCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::GatewayCommandMt> for GatewayCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::GatewayCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::GatewayCommandMt> for GatewayCommand {
	fn from(p: crate::v2_5::types::GatewayCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::GatewayCommandMt> for GatewayCommand {
	fn into(self) -> crate::v2_5::types::GatewayCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of a GatewayCommand.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the GatewayActivity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct GatewayCommandStatus(
	pub crate::v2_5::types::GatewayCommandStatusMt,
);
impl Deref for GatewayCommandStatus {
	type Target = crate::v2_5::types::GatewayCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for GatewayCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::GatewayCommandStatusMt> for GatewayCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::GatewayCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::GatewayCommandStatusMt> for GatewayCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::GatewayCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::GatewayCommandStatusMt> for GatewayCommandStatus {
	fn from(p: crate::v2_5::types::GatewayCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::GatewayCommandStatusMt> for GatewayCommandStatus {
	fn into(self) -> crate::v2_5::types::GatewayCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with Data Processor Capabilities of a Gateway.  Data Processor SettingsCommands generally affect the subsequent operation of applicable Data Processor Capabilities of the Gateway; they are considered presettings, independent of Data Processor command.  Unlike most Data Processor commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct GatewaySettingsCommand(
	pub crate::v2_5::types::GatewaySettingsCommandMt,
);
impl Deref for GatewaySettingsCommand {
	type Target = crate::v2_5::types::GatewaySettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for GatewaySettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::GatewaySettingsCommandMt> for GatewaySettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::GatewaySettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::GatewaySettingsCommandMt> for GatewaySettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::GatewaySettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::GatewaySettingsCommandMt> for GatewaySettingsCommand {
	fn from(p: crate::v2_5::types::GatewaySettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::GatewaySettingsCommandMt> for GatewaySettingsCommand {
	fn into(self) -> crate::v2_5::types::GatewaySettingsCommandMt {
		self.0
	}
}


#[doc = r#"Provides the status of a GatewaySettingsCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct GatewaySettingsCommandStatus(
	pub crate::v2_5::types::GatewaySettingsCommandStatusMt,
);
impl Deref for GatewaySettingsCommandStatus {
	type Target = crate::v2_5::types::GatewaySettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for GatewaySettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::GatewaySettingsCommandStatusMt> for GatewaySettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::GatewaySettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::GatewaySettingsCommandStatusMt> for GatewaySettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::GatewaySettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::GatewaySettingsCommandStatusMt> for GatewaySettingsCommandStatus {
	fn from(p: crate::v2_5::types::GatewaySettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::GatewaySettingsCommandStatusMt> for GatewaySettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::GatewaySettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the IFF Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (IFF_Command) from an Operator or Capability management Service, 3) currently in-work IFF, 4) IFF scheduled for the future and 5) IFF that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single IFF_Command or other triggering event can result in multiple activities within the IFF_Activity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IffActivity(
	pub crate::v2_5::types::IffActivityMt,
);
impl Deref for IffActivity {
	type Target = crate::v2_5::types::IffActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IffActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IffActivityMt> for IffActivity {
	fn as_ref(&self) -> &crate::v2_5::types::IffActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IffActivityMt> for IffActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IffActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IffActivityMt> for IffActivity {
	fn from(p: crate::v2_5::types::IffActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IffActivityMt> for IffActivity {
	fn into(self) -> crate::v2_5::types::IffActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the Identification, Friend or Foe (IFF) category of UCI Capability. It covers both the Transponder and Interrogator SubCapabilities. This message "advertises" the mostly static characteristics of a mission-ready IFF Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IffCapability(
	pub crate::v2_5::types::IffCapabilityMt,
);
impl Deref for IffCapability {
	type Target = crate::v2_5::types::IffCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IffCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IffCapabilityMt> for IffCapability {
	fn as_ref(&self) -> &crate::v2_5::types::IffCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IffCapabilityMt> for IffCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IffCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IffCapabilityMt> for IffCapability {
	fn from(p: crate::v2_5::types::IffCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IffCapabilityMt> for IffCapability {
	fn into(self) -> crate::v2_5::types::IffCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the IFF (Identification, Friend or Foe) capabilities available to the system as advertised in the IFF_Capability message.  This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IffCapabilityStatus(
	pub crate::v2_5::types::IffCapabilityStatusMt,
);
impl Deref for IffCapabilityStatus {
	type Target = crate::v2_5::types::IffCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IffCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IffCapabilityStatusMt> for IffCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::IffCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IffCapabilityStatusMt> for IffCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IffCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IffCapabilityStatusMt> for IffCapabilityStatus {
	fn from(p: crate::v2_5::types::IffCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IffCapabilityStatusMt> for IffCapabilityStatus {
	fn into(self) -> crate::v2_5::types::IffCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the IFF (Identification, Friend or Foe) form of the general UCI Capability Command.  IFF is a communication Capability that has both an Interrogation and Transponder SubCapability.  It is used to manually invoke an IFF Capability to perform a new IFF Activity or to make a change to an existing interactive IFF Activity.  Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IffCommand(
	pub crate::v2_5::types::IffCommandMt,
);
impl Deref for IffCommand {
	type Target = crate::v2_5::types::IffCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IffCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IffCommandMt> for IffCommand {
	fn as_ref(&self) -> &crate::v2_5::types::IffCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IffCommandMt> for IffCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IffCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IffCommandMt> for IffCommand {
	fn from(p: crate::v2_5::types::IffCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IffCommandMt> for IffCommand {
	fn into(self) -> crate::v2_5::types::IffCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an IFF_Command.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the IFF_Activity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IffCommandStatus(
	pub crate::v2_5::types::IffCommandStatusMt,
);
impl Deref for IffCommandStatus {
	type Target = crate::v2_5::types::IffCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IffCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IffCommandStatusMt> for IffCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::IffCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IffCommandStatusMt> for IffCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IffCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IffCommandStatusMt> for IffCommandStatus {
	fn from(p: crate::v2_5::types::IffCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IffCommandStatusMt> for IffCommandStatus {
	fn into(self) -> crate::v2_5::types::IffCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to request consent to perform IFF when applicable.  Status for this command message is provided via the IFF_ConsentRequestStatus message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IffConsentRequest(
	pub crate::v2_5::types::IffConsentRequestMt,
);
impl Deref for IffConsentRequest {
	type Target = crate::v2_5::types::IffConsentRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IffConsentRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IffConsentRequestMt> for IffConsentRequest {
	fn as_ref(&self) -> &crate::v2_5::types::IffConsentRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IffConsentRequestMt> for IffConsentRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IffConsentRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IffConsentRequestMt> for IffConsentRequest {
	fn from(p: crate::v2_5::types::IffConsentRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IffConsentRequestMt> for IffConsentRequest {
	fn into(self) -> crate::v2_5::types::IffConsentRequestMt {
		self.0
	}
}


#[doc = r#"This message is used to report consent request status for its corresponding IFF_ConsentRequest message used to perform IFF capabilities.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IffConsentRequestStatus(
	pub crate::v2_5::types::IffConsentRequestStatusMt,
);
impl Deref for IffConsentRequestStatus {
	type Target = crate::v2_5::types::IffConsentRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IffConsentRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IffConsentRequestStatusMt> for IffConsentRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::IffConsentRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IffConsentRequestStatusMt> for IffConsentRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IffConsentRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IffConsentRequestStatusMt> for IffConsentRequestStatus {
	fn from(p: crate::v2_5::types::IffConsentRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IffConsentRequestStatusMt> for IffConsentRequestStatus {
	fn into(self) -> crate::v2_5::types::IffConsentRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to provide kinematic measurement data and reported data detected from IFF transponders installed on cooperative targets (ie. blue forces or civilian).  This message is typically output from an IFF Interrogator, but could also be output from an IFF Combined Interrogator Transponder (CIT), or IFF transponder with ADS-B IN or Mode 5 Level 2-B IN capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IffMeasurementAndDataReport(
	pub crate::v2_5::types::IffMeasurementAndDataReportMt,
);
impl Deref for IffMeasurementAndDataReport {
	type Target = crate::v2_5::types::IffMeasurementAndDataReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IffMeasurementAndDataReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IffMeasurementAndDataReportMt> for IffMeasurementAndDataReport {
	fn as_ref(&self) -> &crate::v2_5::types::IffMeasurementAndDataReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IffMeasurementAndDataReportMt> for IffMeasurementAndDataReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IffMeasurementAndDataReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IffMeasurementAndDataReportMt> for IffMeasurementAndDataReport {
	fn from(p: crate::v2_5::types::IffMeasurementAndDataReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IffMeasurementAndDataReportMt> for IffMeasurementAndDataReport {
	fn into(self) -> crate::v2_5::types::IffMeasurementAndDataReportMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with the Interrogator SubCapability of the IFF Capabilities of a Subsystem.  There are no relevant commandable settings for the Transponder SubCapability.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered pre-settings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IffSettingsCommand(
	pub crate::v2_5::types::IffSettingsCommandMt,
);
impl Deref for IffSettingsCommand {
	type Target = crate::v2_5::types::IffSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IffSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IffSettingsCommandMt> for IffSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::IffSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IffSettingsCommandMt> for IffSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IffSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IffSettingsCommandMt> for IffSettingsCommand {
	fn from(p: crate::v2_5::types::IffSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IffSettingsCommandMt> for IffSettingsCommand {
	fn into(self) -> crate::v2_5::types::IffSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message is used to report settings status for its corresponding ESM_SettingsCommand message used to change the settings associated with known Identification, Friend or Foe (IFF) capabilities.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IffSettingsCommandStatus(
	pub crate::v2_5::types::IffSettingsCommandStatusMt,
);
impl Deref for IffSettingsCommandStatus {
	type Target = crate::v2_5::types::IffSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IffSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IffSettingsCommandStatusMt> for IffSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::IffSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IffSettingsCommandStatusMt> for IffSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IffSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IffSettingsCommandStatusMt> for IffSettingsCommandStatus {
	fn from(p: crate::v2_5::types::IffSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IffSettingsCommandStatusMt> for IffSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::IffSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message provides the ability to command actions for a User IO Port.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IoPortCommand(
	pub crate::v2_5::types::IoPortCommandMt,
);
impl Deref for IoPortCommand {
	type Target = crate::v2_5::types::IoPortCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IoPortCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IoPortCommandMt> for IoPortCommand {
	fn as_ref(&self) -> &crate::v2_5::types::IoPortCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IoPortCommandMt> for IoPortCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IoPortCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IoPortCommandMt> for IoPortCommand {
	fn from(p: crate::v2_5::types::IoPortCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IoPortCommandMt> for IoPortCommand {
	fn into(self) -> crate::v2_5::types::IoPortCommandMt {
		self.0
	}
}


#[doc = r#"This message is the response to IO_PortCommand and gives the processing status.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IoPortCommandStatus(
	pub crate::v2_5::types::IoPortCommandStatusMt,
);
impl Deref for IoPortCommandStatus {
	type Target = crate::v2_5::types::IoPortCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IoPortCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IoPortCommandStatusMt> for IoPortCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::IoPortCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IoPortCommandStatusMt> for IoPortCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IoPortCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IoPortCommandStatusMt> for IoPortCommandStatus {
	fn from(p: crate::v2_5::types::IoPortCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IoPortCommandStatusMt> for IoPortCommandStatus {
	fn into(self) -> crate::v2_5::types::IoPortCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message contains the status and settings for each User I/O Port relevant to mission operations.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct IoPortStatus(
	pub crate::v2_5::types::IoPortStatusMt,
);
impl Deref for IoPortStatus {
	type Target = crate::v2_5::types::IoPortStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for IoPortStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::IoPortStatusMt> for IoPortStatus {
	fn as_ref(&self) -> &crate::v2_5::types::IoPortStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::IoPortStatusMt> for IoPortStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::IoPortStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::IoPortStatusMt> for IoPortStatus {
	fn from(p: crate::v2_5::types::IoPortStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::IoPortStatusMt> for IoPortStatus {
	fn into(self) -> crate::v2_5::types::IoPortStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to allow subsystems to report that jamming is detected and, if available, the direction in which it is coming from.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct JamStrobeReport(
	pub crate::v2_5::types::JamStrobeReportMt,
);
impl Deref for JamStrobeReport {
	type Target = crate::v2_5::types::JamStrobeReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for JamStrobeReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::JamStrobeReportMt> for JamStrobeReport {
	fn as_ref(&self) -> &crate::v2_5::types::JamStrobeReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::JamStrobeReportMt> for JamStrobeReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::JamStrobeReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::JamStrobeReportMt> for JamStrobeReport {
	fn from(p: crate::v2_5::types::JamStrobeReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::JamStrobeReportMt> for JamStrobeReport {
	fn into(self) -> crate::v2_5::types::JamStrobeReportMt {
		self.0
	}
}


#[doc = r#"This message contains a representation of an Land (Equipment) Record within an Order of Battle.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct LandRecord(
	pub crate::v2_5::types::LandRecordMt,
);
impl Deref for LandRecord {
	type Target = crate::v2_5::types::LandRecordMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for LandRecord {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::LandRecordMt> for LandRecord {
	fn as_ref(&self) -> &crate::v2_5::types::LandRecordMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::LandRecordMt> for LandRecord {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::LandRecordMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::LandRecordMt> for LandRecord {
	fn from(p: crate::v2_5::types::LandRecordMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::LandRecordMt> for LandRecord {
	fn into(self) -> crate::v2_5::types::LandRecordMt {
		self.0
	}
}


#[doc = r#"This message represents a single Launch Acceptability Region (LAR).UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Lar(
	pub crate::v2_5::types::LarMt,
);
impl Deref for Lar {
	type Target = crate::v2_5::types::LarMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Lar {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::LarMt> for Lar {
	fn as_ref(&self) -> &crate::v2_5::types::LarMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::LarMt> for Lar {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::LarMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::LarMt> for Lar {
	fn from(p: crate::v2_5::types::LarMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::LarMt> for Lar {
	fn into(self) -> crate::v2_5::types::LarMt {
		self.0
	}
}


#[doc = r#"This message provides a System's status in relation to a Launch Acceptability Region (LAR).UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct LarReport(
	pub crate::v2_5::types::LarReportMt,
);
impl Deref for LarReport {
	type Target = crate::v2_5::types::LarReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for LarReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::LarReportMt> for LarReport {
	fn as_ref(&self) -> &crate::v2_5::types::LarReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::LarReportMt> for LarReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::LarReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::LarReportMt> for LarReport {
	fn from(p: crate::v2_5::types::LarReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::LarReportMt> for LarReport {
	fn into(self) -> crate::v2_5::types::LarReportMt {
		self.0
	}
}


#[doc = r#"This message is used to request the generation of a Launch Acceptability Region (LAR) for a weapon.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct LarRequest(
	pub crate::v2_5::types::LarRequestMt,
);
impl Deref for LarRequest {
	type Target = crate::v2_5::types::LarRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for LarRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::LarRequestMt> for LarRequest {
	fn as_ref(&self) -> &crate::v2_5::types::LarRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::LarRequestMt> for LarRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::LarRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::LarRequestMt> for LarRequest {
	fn from(p: crate::v2_5::types::LarRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::LarRequestMt> for LarRequest {
	fn into(self) -> crate::v2_5::types::LarRequestMt {
		self.0
	}
}


#[doc = r#"This message provides status for a previously submitted LAR_Request.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct LarRequestStatus(
	pub crate::v2_5::types::LarRequestStatusMt,
);
impl Deref for LarRequestStatus {
	type Target = crate::v2_5::types::LarRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for LarRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::LarRequestStatusMt> for LarRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::LarRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::LarRequestStatusMt> for LarRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::LarRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::LarRequestStatusMt> for LarRequestStatus {
	fn from(p: crate::v2_5::types::LarRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::LarRequestStatusMt> for LarRequestStatus {
	fn into(self) -> crate::v2_5::types::LarRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message provides the ability for a system to report an observation for an identified launch event or changes during a launch event. This message includes the reporting of stage separation through the lifecycle of a multi-stage launch event. Providing the stage of the launch at the time of observation allows the consumer to identify what Entity is continuing in the launch and what Entity is no longer continuing in the launch.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct LaunchObservation(
	pub crate::v2_5::types::LaunchObservationMt,
);
impl Deref for LaunchObservation {
	type Target = crate::v2_5::types::LaunchObservationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for LaunchObservation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::LaunchObservationMt> for LaunchObservation {
	fn as_ref(&self) -> &crate::v2_5::types::LaunchObservationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::LaunchObservationMt> for LaunchObservation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::LaunchObservationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::LaunchObservationMt> for LaunchObservation {
	fn from(p: crate::v2_5::types::LaunchObservationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::LaunchObservationMt> for LaunchObservation {
	fn into(self) -> crate::v2_5::types::LaunchObservationMt {
		self.0
	}
}


#[doc = r#"This message is intended to support centralized, OS agnostic logging by a service/subsystem/component/capability related to the operation or information of a service/subsystem/component/capability.  For example, the Message data could be captured and stored by a log aggregator and used for display and post mission analysis.  This differs from messages such as SubsystemStream which is intended for debugging in real time and Subsystem unique data that cannot be standardized; or ServiceErrorReport which is intended for error awareness.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Log(
	pub crate::v2_5::types::LogMt,
);
impl Deref for Log {
	type Target = crate::v2_5::types::LogMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Log {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::LogMt> for Log {
	fn as_ref(&self) -> &crate::v2_5::types::LogMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::LogMt> for Log {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::LogMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::LogMt> for Log {
	fn from(p: crate::v2_5::types::LogMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::LogMt> for Log {
	fn into(self) -> crate::v2_5::types::LogMt {
		self.0
	}
}


#[doc = r#"This message is intended to provide a consolidated list of records that will update the MessageTransmissionListUCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MessageTransmissionFilterRecord(
	pub crate::v2_5::types::MessageTransmissionFilterRecordMt,
);
impl Deref for MessageTransmissionFilterRecord {
	type Target = crate::v2_5::types::MessageTransmissionFilterRecordMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MessageTransmissionFilterRecord {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MessageTransmissionFilterRecordMt> for MessageTransmissionFilterRecord {
	fn as_ref(&self) -> &crate::v2_5::types::MessageTransmissionFilterRecordMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MessageTransmissionFilterRecordMt> for MessageTransmissionFilterRecord {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MessageTransmissionFilterRecordMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MessageTransmissionFilterRecordMt> for MessageTransmissionFilterRecord {
	fn from(p: crate::v2_5::types::MessageTransmissionFilterRecordMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MessageTransmissionFilterRecordMt> for MessageTransmissionFilterRecord {
	fn into(self) -> crate::v2_5::types::MessageTransmissionFilterRecordMt {
		self.0
	}
}


#[doc = r#"This message contains a list of message information IDs that a system should expose to other UCI compliant systems.  This allows system operator involvement in selection of objects for transmit. This enables selectable data sharing between UCI compliant systems.  For example, this message could be used to coordinate, amongst Services within a System, which UCI messages they should publish to UCI nodes outside the SystemUCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MessageTransmissionList(
	pub crate::v2_5::types::MessageTransmissionListMt,
);
impl Deref for MessageTransmissionList {
	type Target = crate::v2_5::types::MessageTransmissionListMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MessageTransmissionList {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MessageTransmissionListMt> for MessageTransmissionList {
	fn as_ref(&self) -> &crate::v2_5::types::MessageTransmissionListMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MessageTransmissionListMt> for MessageTransmissionList {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MessageTransmissionListMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MessageTransmissionListMt> for MessageTransmissionList {
	fn from(p: crate::v2_5::types::MessageTransmissionListMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MessageTransmissionListMt> for MessageTransmissionList {
	fn into(self) -> crate::v2_5::types::MessageTransmissionListMt {
		self.0
	}
}


#[doc = r#"This message contains a representation of a Missile Record within an Order of Battle.UCI_PRIMITIVE: DataRecord-1"#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissileRecord(
	pub crate::v2_5::types::MissileRecordMt,
);
impl Deref for MissileRecord {
	type Target = crate::v2_5::types::MissileRecordMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissileRecord {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissileRecordMt> for MissileRecord {
	fn as_ref(&self) -> &crate::v2_5::types::MissileRecordMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissileRecordMt> for MissileRecord {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissileRecordMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissileRecordMt> for MissileRecord {
	fn from(p: crate::v2_5::types::MissileRecordMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissileRecordMt> for MissileRecord {
	fn into(self) -> crate::v2_5::types::MissileRecordMt {
		self.0
	}
}


#[doc = r#"This message defines a mission that spans multiple vehicles and its associated parameters needed for planning and execution.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Mission(
	pub crate::v2_5::types::MissionMt,
);
impl Deref for Mission {
	type Target = crate::v2_5::types::MissionMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Mission {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionMt> for Mission {
	fn as_ref(&self) -> &crate::v2_5::types::MissionMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionMt> for Mission {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionMt> for Mission {
	fn from(p: crate::v2_5::types::MissionMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionMt> for Mission {
	fn into(self) -> crate::v2_5::types::MissionMt {
		self.0
	}
}


#[doc = r#"This message requests that a Mission "session", previously defined by Mission, be activated or deactivated.  For example, a previously defined and saved Mission can be activated which triggers loading of the Mission, Service initialization, querying for persisted data, etc.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionActivationRequest(
	pub crate::v2_5::types::MissionActivationRequestMt,
);
impl Deref for MissionActivationRequest {
	type Target = crate::v2_5::types::MissionActivationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionActivationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionActivationRequestMt> for MissionActivationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::MissionActivationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionActivationRequestMt> for MissionActivationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionActivationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionActivationRequestMt> for MissionActivationRequest {
	fn from(p: crate::v2_5::types::MissionActivationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionActivationRequestMt> for MissionActivationRequest {
	fn into(self) -> crate::v2_5::types::MissionActivationRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of a request to action a Mission to a new state.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionActivationRequestStatus(
	pub crate::v2_5::types::MissionActivationRequestStatusMt,
);
impl Deref for MissionActivationRequestStatus {
	type Target = crate::v2_5::types::MissionActivationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionActivationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionActivationRequestStatusMt> for MissionActivationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionActivationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionActivationRequestStatusMt> for MissionActivationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionActivationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionActivationRequestStatusMt> for MissionActivationRequestStatus {
	fn from(p: crate::v2_5::types::MissionActivationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionActivationRequestStatusMt> for MissionActivationRequestStatus {
	fn into(self) -> crate::v2_5::types::MissionActivationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates status/state of approval for an Mission.  Approval may or may not be required.  ApprovalPolicy aligned with the Mission and states of planning allow a planning oversight authority to approve or reject Missions as they're created or updated.  Approval may or may not be required.  If required, there may be many approvers.  See Approval* messages for additional details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionApprovalStatus(
	pub crate::v2_5::types::MissionApprovalStatusMt,
);
impl Deref for MissionApprovalStatus {
	type Target = crate::v2_5::types::MissionApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionApprovalStatusMt> for MissionApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionApprovalStatusMt> for MissionApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionApprovalStatusMt> for MissionApprovalStatus {
	fn from(p: crate::v2_5::types::MissionApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionApprovalStatusMt> for MissionApprovalStatus {
	fn into(self) -> crate::v2_5::types::MissionApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message provides an alert that a triggering condition for autonomous functions has occurred.  It also indicates the autonomous response if applicable.  The messages PlanningFunction*, Approval*, MissionContingencyAlert and ControlStatus are closely related.  They use a common taxonomy of autonomous functions (task allocation, route planning, mission activation and mission execution), triggers for those functions (new threats, new zones, failures, etc.) and results of those functions (dropped Tasks, changes in vulnerability, etc.).  ControlStatus indicates the full set of available autonomous functions/settings of a System.  PlanningFunction* indicates how the available settings are currently configured.  MissionContingencyAlert indicates an autonomous function/setting that has been triggered.  Approval* messages allow Operators to approve the results of autonomous responses as needed.  MissionContingencyAlert is a bit of a misnomer for this message as it uses the word "contingency" while the other messages use the word "autonomy"; this message could be called AutonomyAlert.  All autonomous functions represented by these messages issue MissionContingencyAlerts when triggered, per the active autonomy settings.  Additionally, MissionContingencyAlerts can be issued even if an autonomous response isn't taken, again per the active autonomy settings; if autonomous response is not allowed based on the autonomy settings, a recommended course of action is provided to the operator. This message is not intended to invoke autonomous functions itself but will provide:
1. Insight into the occurrence of triggering conditions of autonomous functions.
2. An indication that the system is in the process of autonomously addressing the contingency.
3. A recommended course of action if autonomy is not allowed.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionContingencyAlert(
	pub crate::v2_5::types::MissionContingencyAlertMt,
);
impl Deref for MissionContingencyAlert {
	type Target = crate::v2_5::types::MissionContingencyAlertMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionContingencyAlert {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionContingencyAlertMt> for MissionContingencyAlert {
	fn as_ref(&self) -> &crate::v2_5::types::MissionContingencyAlertMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionContingencyAlertMt> for MissionContingencyAlert {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionContingencyAlertMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionContingencyAlertMt> for MissionContingencyAlert {
	fn from(p: crate::v2_5::types::MissionContingencyAlertMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionContingencyAlertMt> for MissionContingencyAlert {
	fn into(self) -> crate::v2_5::types::MissionContingencyAlertMt {
		self.0
	}
}


#[doc = r#"This message is an indicator to planning services to modify their planning information from what is currently known.  Various items in planning objects can be changed.  Overrides modify the behavior of planning and not the original objects.  For example the ELNOT of an EOB Entity can be overridden to a different ELNOT during planning.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionEnvironmentOverride(
	pub crate::v2_5::types::MissionEnvironmentOverrideMt,
);
impl Deref for MissionEnvironmentOverride {
	type Target = crate::v2_5::types::MissionEnvironmentOverrideMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionEnvironmentOverride {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionEnvironmentOverrideMt> for MissionEnvironmentOverride {
	fn as_ref(&self) -> &crate::v2_5::types::MissionEnvironmentOverrideMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionEnvironmentOverrideMt> for MissionEnvironmentOverride {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionEnvironmentOverrideMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionEnvironmentOverrideMt> for MissionEnvironmentOverride {
	fn from(p: crate::v2_5::types::MissionEnvironmentOverrideMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionEnvironmentOverrideMt> for MissionEnvironmentOverride {
	fn into(self) -> crate::v2_5::types::MissionEnvironmentOverrideMt {
		self.0
	}
}


#[doc = r#"This message specifies an integrated set of sub-*Plans (TaskPlan, RoutePlan and RouteActivityPlan for example) that together are the mission plan for a single System.  Mission planning can be done manually by operators, by planning services or a combination.  This message references a set of coherent sub-*Plans and indicates the order in which they will be executed when activated.  The sub-*Plans can be discretely created then integrated into the MissionPlan or created near simultaneously in a single or multiple step mission planning process that creates all sub-*Plans.  A MissionPlan can be created, updated and approved somewhat independent of its sub-*Plans.  For a hierarchical System of Systems, a higher tiered System's MissionPlan can reference the related/coherent MissionPlans of subordinate Systems.
*Plans can only be activated and executed as part of a MissionPlan.  A MissionPlan can be subject to approval per Approval* messages.  Planning, approval, activation and execution state information for a MissionPlan are given in other MissionPlan* messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlan(
	pub crate::v2_5::types::MissionPlanMt,
);
impl Deref for MissionPlan {
	type Target = crate::v2_5::types::MissionPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanMt> for MissionPlan {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanMt> for MissionPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanMt> for MissionPlan {
	fn from(p: crate::v2_5::types::MissionPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanMt> for MissionPlan {
	fn into(self) -> crate::v2_5::types::MissionPlanMt {
		self.0
	}
}


#[doc = r#"This message indicates the Activation Approval status of a Mission Plan and optionally the sub-plans.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanActivationApprovalStatus(
	pub crate::v2_5::types::MissionPlanActivationApprovalStatusMt,
);
impl Deref for MissionPlanActivationApprovalStatus {
	type Target = crate::v2_5::types::MissionPlanActivationApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanActivationApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanActivationApprovalStatusMt> for MissionPlanActivationApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanActivationApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanActivationApprovalStatusMt> for MissionPlanActivationApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanActivationApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanActivationApprovalStatusMt> for MissionPlanActivationApprovalStatus {
	fn from(p: crate::v2_5::types::MissionPlanActivationApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanActivationApprovalStatusMt> for MissionPlanActivationApprovalStatus {
	fn into(self) -> crate::v2_5::types::MissionPlanActivationApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message provides the ability to command activation of *Plan(s).UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanActivationCommand(
	pub crate::v2_5::types::MissionPlanActivationCommandMt,
);
impl Deref for MissionPlanActivationCommand {
	type Target = crate::v2_5::types::MissionPlanActivationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanActivationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanActivationCommandMt> for MissionPlanActivationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanActivationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanActivationCommandMt> for MissionPlanActivationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanActivationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanActivationCommandMt> for MissionPlanActivationCommand {
	fn from(p: crate::v2_5::types::MissionPlanActivationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanActivationCommandMt> for MissionPlanActivationCommand {
	fn into(self) -> crate::v2_5::types::MissionPlanActivationCommandMt {
		self.0
	}
}


#[doc = r#"This message is the response to a MissionPlanActivationCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanActivationCommandStatus(
	pub crate::v2_5::types::MissionPlanActivationCommandStatusMt,
);
impl Deref for MissionPlanActivationCommandStatus {
	type Target = crate::v2_5::types::MissionPlanActivationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanActivationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanActivationCommandStatusMt> for MissionPlanActivationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanActivationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanActivationCommandStatusMt> for MissionPlanActivationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanActivationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanActivationCommandStatusMt> for MissionPlanActivationCommandStatus {
	fn from(p: crate::v2_5::types::MissionPlanActivationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanActivationCommandStatusMt> for MissionPlanActivationCommandStatus {
	fn into(self) -> crate::v2_5::types::MissionPlanActivationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message provides status of a mission plan and its subplans along the planning, conversion, upload, and activation chain.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanActivationStatus(
	pub crate::v2_5::types::MissionPlanActivationStatusMt,
);
impl Deref for MissionPlanActivationStatus {
	type Target = crate::v2_5::types::MissionPlanActivationStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanActivationStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanActivationStatusMt> for MissionPlanActivationStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanActivationStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanActivationStatusMt> for MissionPlanActivationStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanActivationStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanActivationStatusMt> for MissionPlanActivationStatus {
	fn from(p: crate::v2_5::types::MissionPlanActivationStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanActivationStatusMt> for MissionPlanActivationStatus {
	fn into(self) -> crate::v2_5::types::MissionPlanActivationStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates status/state of approval for a MissionPlan.  Approval may or may not be required.  ApprovalPolicy aligned with the *Plans and states of planning allow a planning oversight authority to approve or reject plans as they're created or updated.  Approval may or may not be required.  If required, there may be many approvers.  See Approval* messages for additional details.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanApprovalStatus(
	pub crate::v2_5::types::MissionPlanApprovalStatusMt,
);
impl Deref for MissionPlanApprovalStatus {
	type Target = crate::v2_5::types::MissionPlanApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanApprovalStatusMt> for MissionPlanApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanApprovalStatusMt> for MissionPlanApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanApprovalStatusMt> for MissionPlanApprovalStatus {
	fn from(p: crate::v2_5::types::MissionPlanApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanApprovalStatusMt> for MissionPlanApprovalStatus {
	fn into(self) -> crate::v2_5::types::MissionPlanApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message invokes a MissionPlan planning process.  Each planning process is declared with a unique ID in the ControlStatus message; that ID is used in this message to invoke the process.  A MissionPlan is an aggregation of other *Plan types, therefore MissionPlanCommand planning processes (and this message) can result in multiple *Plan types/messages.  This message includes many inputs to the planning process but many others may come from a variety of other messages.  A few examples of the many inputs include:
1. Options for constraining the planning function in a variety of ways using existing Plans of the same type or by other Plan types.  For example, a MissionPlan could be constrained by a previous RoutePlan, a previous RouteActivityPlan and/or a TaskPlan.
2. Environment overrides to selectively modify details of the current planning environment in the context of a single planning command. For example, a known threat Entity in the environment could be removed and an expected Entity could be added to the environment in the context of a single planning command in support of "what-if" planning.
3. "Weightings" that influence the decisions of operators or planning algorithms performing the planning.
4. Temporal and/or kinematic begin and end points.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanCommand(
	pub crate::v2_5::types::MissionPlanCommandMt,
);
impl Deref for MissionPlanCommand {
	type Target = crate::v2_5::types::MissionPlanCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanCommandMt> for MissionPlanCommand {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanCommandMt> for MissionPlanCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanCommandMt> for MissionPlanCommand {
	fn from(p: crate::v2_5::types::MissionPlanCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanCommandMt> for MissionPlanCommand {
	fn into(self) -> crate::v2_5::types::MissionPlanCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to create/update a MissionPlan, including the current state in a command and processing state machine; see the MissionPlanCommand message.  Creation/update of a MissionPlan  may occur autonomously, without a MissionPlanCommand in which case the current state of the plan could be given in the MissionPlanStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanCommandStatus(
	pub crate::v2_5::types::MissionPlanCommandStatusMt,
);
impl Deref for MissionPlanCommandStatus {
	type Target = crate::v2_5::types::MissionPlanCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanCommandStatusMt> for MissionPlanCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanCommandStatusMt> for MissionPlanCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanCommandStatusMt> for MissionPlanCommandStatus {
	fn from(p: crate::v2_5::types::MissionPlanCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanCommandStatusMt> for MissionPlanCommandStatus {
	fn into(self) -> crate::v2_5::types::MissionPlanCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the execution status for one or more MissionPlans.  Plan execution begins after successful autonomous plan activation or activation via MissionPlanActivation messages.  This message provides execution status regardless of how execution was initiated.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanExecutionStatus(
	pub crate::v2_5::types::MissionPlanExecutionStatusMt,
);
impl Deref for MissionPlanExecutionStatus {
	type Target = crate::v2_5::types::MissionPlanExecutionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanExecutionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanExecutionStatusMt> for MissionPlanExecutionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanExecutionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanExecutionStatusMt> for MissionPlanExecutionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanExecutionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanExecutionStatusMt> for MissionPlanExecutionStatus {
	fn from(p: crate::v2_5::types::MissionPlanExecutionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanExecutionStatusMt> for MissionPlanExecutionStatus {
	fn into(self) -> crate::v2_5::types::MissionPlanExecutionStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies an aggregation of metrics on which to judge the success of a mission.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanMetricsReport(
	pub crate::v2_5::types::MissionPlanMetricsReportMt,
);
impl Deref for MissionPlanMetricsReport {
	type Target = crate::v2_5::types::MissionPlanMetricsReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanMetricsReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanMetricsReportMt> for MissionPlanMetricsReport {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanMetricsReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanMetricsReportMt> for MissionPlanMetricsReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanMetricsReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanMetricsReportMt> for MissionPlanMetricsReport {
	fn from(p: crate::v2_5::types::MissionPlanMetricsReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanMetricsReportMt> for MissionPlanMetricsReport {
	fn into(self) -> crate::v2_5::types::MissionPlanMetricsReportMt {
		self.0
	}
}


#[doc = r#"This message requests post-mission or in-mission metrics for a MissionPlan.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanMetricsReportRequest(
	pub crate::v2_5::types::MissionPlanMetricsReportRequestMt,
);
impl Deref for MissionPlanMetricsReportRequest {
	type Target = crate::v2_5::types::MissionPlanMetricsReportRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanMetricsReportRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanMetricsReportRequestMt> for MissionPlanMetricsReportRequest {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanMetricsReportRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanMetricsReportRequestMt> for MissionPlanMetricsReportRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanMetricsReportRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanMetricsReportRequestMt> for MissionPlanMetricsReportRequest {
	fn from(p: crate::v2_5::types::MissionPlanMetricsReportRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanMetricsReportRequestMt> for MissionPlanMetricsReportRequest {
	fn into(self) -> crate::v2_5::types::MissionPlanMetricsReportRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status of a MissionPlanMetricsReportRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanMetricsReportRequestStatus(
	pub crate::v2_5::types::MissionPlanMetricsReportRequestStatusMt,
);
impl Deref for MissionPlanMetricsReportRequestStatus {
	type Target = crate::v2_5::types::MissionPlanMetricsReportRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanMetricsReportRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanMetricsReportRequestStatusMt> for MissionPlanMetricsReportRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanMetricsReportRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanMetricsReportRequestStatusMt> for MissionPlanMetricsReportRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanMetricsReportRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanMetricsReportRequestStatusMt> for MissionPlanMetricsReportRequestStatus {
	fn from(p: crate::v2_5::types::MissionPlanMetricsReportRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanMetricsReportRequestStatusMt> for MissionPlanMetricsReportRequestStatus {
	fn into(self) -> crate::v2_5::types::MissionPlanMetricsReportRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message provides status for a MissionPlan.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanStatus(
	pub crate::v2_5::types::MissionPlanStatusMt,
);
impl Deref for MissionPlanStatus {
	type Target = crate::v2_5::types::MissionPlanStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanStatusMt> for MissionPlanStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanStatusMt> for MissionPlanStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanStatusMt> for MissionPlanStatus {
	fn from(p: crate::v2_5::types::MissionPlanStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanStatusMt> for MissionPlanStatus {
	fn into(self) -> crate::v2_5::types::MissionPlanStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the validation, including the current state in a validation state machine, and details of invalid items. Validation may occur periodically, or onesie twosie. See the MissionPlanValidationCommand message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanValidation(
	pub crate::v2_5::types::MissionPlanValidationMt,
);
impl Deref for MissionPlanValidation {
	type Target = crate::v2_5::types::MissionPlanValidationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanValidation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanValidationMt> for MissionPlanValidation {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanValidationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanValidationMt> for MissionPlanValidation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanValidationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanValidationMt> for MissionPlanValidation {
	fn from(p: crate::v2_5::types::MissionPlanValidationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanValidationMt> for MissionPlanValidation {
	fn into(self) -> crate::v2_5::types::MissionPlanValidationMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to validate/re-validate an existing MissionPlan.  A MissionPlan can become invalid due to changes in Task timing, weather, order of battle, kinematic movement constraints, operator manual edits and many, many other reasons.  The message allows an existing MissionPlan to be checked for validity given such changes.  The variables a given planning service, operator or system considers when validating a plan varies.  Different variables might be considered depending on the level of detail of the plan or stage in the overall planning process.  The scope and meaning of "valid" comes from context of the services, operator and systems creating the plan.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanValidationCommand(
	pub crate::v2_5::types::MissionPlanValidationCommandMt,
);
impl Deref for MissionPlanValidationCommand {
	type Target = crate::v2_5::types::MissionPlanValidationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanValidationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanValidationCommandMt> for MissionPlanValidationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanValidationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanValidationCommandMt> for MissionPlanValidationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanValidationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanValidationCommandMt> for MissionPlanValidationCommand {
	fn from(p: crate::v2_5::types::MissionPlanValidationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanValidationCommandMt> for MissionPlanValidationCommand {
	fn into(self) -> crate::v2_5::types::MissionPlanValidationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to validate a MissionPlan, including the current state in a command and processing state machine.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanValidationCommandStatus(
	pub crate::v2_5::types::MissionPlanValidationCommandStatusMt,
);
impl Deref for MissionPlanValidationCommandStatus {
	type Target = crate::v2_5::types::MissionPlanValidationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanValidationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanValidationCommandStatusMt> for MissionPlanValidationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanValidationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanValidationCommandStatusMt> for MissionPlanValidationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanValidationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanValidationCommandStatusMt> for MissionPlanValidationCommandStatus {
	fn from(p: crate::v2_5::types::MissionPlanValidationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanValidationCommandStatusMt> for MissionPlanValidationCommandStatus {
	fn into(self) -> crate::v2_5::types::MissionPlanValidationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message enables a controlling system to define how its planning processes link to subordinate planning processes.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionPlanningOrchestration(
	pub crate::v2_5::types::MissionPlanningOrchestrationMt,
);
impl Deref for MissionPlanningOrchestration {
	type Target = crate::v2_5::types::MissionPlanningOrchestrationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionPlanningOrchestration {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionPlanningOrchestrationMt> for MissionPlanningOrchestration {
	fn as_ref(&self) -> &crate::v2_5::types::MissionPlanningOrchestrationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionPlanningOrchestrationMt> for MissionPlanningOrchestration {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionPlanningOrchestrationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionPlanningOrchestrationMt> for MissionPlanningOrchestration {
	fn from(p: crate::v2_5::types::MissionPlanningOrchestrationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionPlanningOrchestrationMt> for MissionPlanningOrchestration {
	fn into(self) -> crate::v2_5::types::MissionPlanningOrchestrationMt {
		self.0
	}
}


#[doc = r#"This message provides the status of the Requirements of a given MissionPlan.  It enables aggregation of Requirement planning, execution approval and execution status per MissionPlan.  This message provides no more information than is already available directly in the corresponding Requirement status messages; TaskPlanningStatus, TaskExecutionApprovalStatus and TaskStatus for example.  It is as an optional mechanism for reporting and monitoring the progress of a mission, from a Requirement perspective, through a single message.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionRequirementStatus(
	pub crate::v2_5::types::MissionRequirementStatusMt,
);
impl Deref for MissionRequirementStatus {
	type Target = crate::v2_5::types::MissionRequirementStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionRequirementStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionRequirementStatusMt> for MissionRequirementStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionRequirementStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionRequirementStatusMt> for MissionRequirementStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionRequirementStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionRequirementStatusMt> for MissionRequirementStatus {
	fn from(p: crate::v2_5::types::MissionRequirementStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionRequirementStatusMt> for MissionRequirementStatus {
	fn into(self) -> crate::v2_5::types::MissionRequirementStatusMt {
		self.0
	}
}


#[doc = r#"This message provides status for a Mission.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionStatus(
	pub crate::v2_5::types::MissionStatusMt,
);
impl Deref for MissionStatus {
	type Target = crate::v2_5::types::MissionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionStatusMt> for MissionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionStatusMt> for MissionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionStatusMt> for MissionStatus {
	fn from(p: crate::v2_5::types::MissionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionStatusMt> for MissionStatus {
	fn into(self) -> crate::v2_5::types::MissionStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the validation, including the current state in a validation state machine, and details of invalid items. Validation may occur periodically, or onesie twosie. See the MissionValidationCommand message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionValidation(
	pub crate::v2_5::types::MissionValidationMt,
);
impl Deref for MissionValidation {
	type Target = crate::v2_5::types::MissionValidationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionValidation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionValidationMt> for MissionValidation {
	fn as_ref(&self) -> &crate::v2_5::types::MissionValidationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionValidationMt> for MissionValidation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionValidationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionValidationMt> for MissionValidation {
	fn from(p: crate::v2_5::types::MissionValidationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionValidationMt> for MissionValidation {
	fn into(self) -> crate::v2_5::types::MissionValidationMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to validate/re-validate an existing Mission.  It includes an option to modiff to make it valid if it is found to be invalid.  A Mission can become invalid due to changes in Task timing, weather, order of battle, kinematic movement constraints, operator manual edits and many, many other reasons.  The message allows an existing Mission to be checked for validity given such changes.  The variables a given planning service, operator or system considers when validating a Mission varies.  Different variables might be considered depending on the level of detail of the Mission or stage in the overall planning process.  The scope and meaning of "valid" comes from context of the services, operator and systems creating the Mission.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionValidationCommand(
	pub crate::v2_5::types::MissionValidationCommandMt,
);
impl Deref for MissionValidationCommand {
	type Target = crate::v2_5::types::MissionValidationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionValidationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionValidationCommandMt> for MissionValidationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::MissionValidationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionValidationCommandMt> for MissionValidationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionValidationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionValidationCommandMt> for MissionValidationCommand {
	fn from(p: crate::v2_5::types::MissionValidationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionValidationCommandMt> for MissionValidationCommand {
	fn into(self) -> crate::v2_5::types::MissionValidationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to validate an Mission, including the current state in a command and processing state machine.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MissionValidationCommandStatus(
	pub crate::v2_5::types::MissionValidationCommandStatusMt,
);
impl Deref for MissionValidationCommandStatus {
	type Target = crate::v2_5::types::MissionValidationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MissionValidationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MissionValidationCommandStatusMt> for MissionValidationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::MissionValidationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MissionValidationCommandStatusMt> for MissionValidationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MissionValidationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MissionValidationCommandStatusMt> for MissionValidationCommandStatus {
	fn from(p: crate::v2_5::types::MissionValidationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MissionValidationCommandStatusMt> for MissionValidationCommandStatus {
	fn into(self) -> crate::v2_5::types::MissionValidationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message provides the ability for the AMTI, SAR, and SMTI capabilities to identify the location and associated waveform information of specific emitters while performing multistatic operations.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MultistaticEmitterData(
	pub crate::v2_5::types::MultistaticEmitterDataMt,
);
impl Deref for MultistaticEmitterData {
	type Target = crate::v2_5::types::MultistaticEmitterDataMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MultistaticEmitterData {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MultistaticEmitterDataMt> for MultistaticEmitterData {
	fn as_ref(&self) -> &crate::v2_5::types::MultistaticEmitterDataMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MultistaticEmitterDataMt> for MultistaticEmitterData {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MultistaticEmitterDataMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MultistaticEmitterDataMt> for MultistaticEmitterData {
	fn from(p: crate::v2_5::types::MultistaticEmitterDataMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MultistaticEmitterDataMt> for MultistaticEmitterData {
	fn into(self) -> crate::v2_5::types::MultistaticEmitterDataMt {
		self.0
	}
}


#[doc = r#"This message provides the ability for a system to report a notification of significant changes in visual magnitude of a Resident Space Object (RSO). This message is the result of the processing of information reported by other systems thus giving this a confidence of the observation.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct MvAnomalyEvent(
	pub crate::v2_5::types::MvAnomalyEventMt,
);
impl Deref for MvAnomalyEvent {
	type Target = crate::v2_5::types::MvAnomalyEventMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for MvAnomalyEvent {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::MvAnomalyEventMt> for MvAnomalyEvent {
	fn as_ref(&self) -> &crate::v2_5::types::MvAnomalyEventMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::MvAnomalyEventMt> for MvAnomalyEvent {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::MvAnomalyEventMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::MvAnomalyEventMt> for MvAnomalyEvent {
	fn from(p: crate::v2_5::types::MvAnomalyEventMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::MvAnomalyEventMt> for MvAnomalyEvent {
	fn into(self) -> crate::v2_5::types::MvAnomalyEventMt {
		self.0
	}
}


#[doc = r#"A [Capability]Activity message describes what a Capability is actively doing. It is generally a complete, coherent snapshot of all Activities for a Capability category (ESM, EA, etc.). In UCI terminology, an Activity is the dynamic, per-use status of a Capability. An Activity is an abstraction that includes the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct NavigationActivity(
	pub crate::v2_5::types::NavigationActivityMt,
);
impl Deref for NavigationActivity {
	type Target = crate::v2_5::types::NavigationActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for NavigationActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::NavigationActivityMt> for NavigationActivity {
	fn as_ref(&self) -> &crate::v2_5::types::NavigationActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::NavigationActivityMt> for NavigationActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::NavigationActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::NavigationActivityMt> for NavigationActivity {
	fn from(p: crate::v2_5::types::NavigationActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::NavigationActivityMt> for NavigationActivity {
	fn into(self) -> crate::v2_5::types::NavigationActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the Navigation category of UCI Capability.  It "advertises" the mostly static characteristics of a Navigation Capability so that it can be "discovered" and used. "Discovery" can be a misnomer depending on your perspective. UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities. They don't eliminate the need for future software updates or configuration files. UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission. In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services. A [Capability]Capability message describes what a Subsystem is capable of doing if invoked. A [Capability]Activity message describes what a Capability is doing. Capabilities are aligned with end effects of Mission operations and for the Navigation Capability, it could be a required route sequence, orbit/loiter point, etc.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct NavigationCapability(
	pub crate::v2_5::types::NavigationCapabilityMt,
);
impl Deref for NavigationCapability {
	type Target = crate::v2_5::types::NavigationCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for NavigationCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::NavigationCapabilityMt> for NavigationCapability {
	fn as_ref(&self) -> &crate::v2_5::types::NavigationCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::NavigationCapabilityMt> for NavigationCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::NavigationCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::NavigationCapabilityMt> for NavigationCapability {
	fn from(p: crate::v2_5::types::NavigationCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::NavigationCapabilityMt> for NavigationCapability {
	fn into(self) -> crate::v2_5::types::NavigationCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Navigation capabilities of a System. This includes information regarding whether or not each capability is currently available based on hardware status, operational states, etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct NavigationCapabilityStatus(
	pub crate::v2_5::types::NavigationCapabilityStatusMt,
);
impl Deref for NavigationCapabilityStatus {
	type Target = crate::v2_5::types::NavigationCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for NavigationCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::NavigationCapabilityStatusMt> for NavigationCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::NavigationCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::NavigationCapabilityStatusMt> for NavigationCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::NavigationCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::NavigationCapabilityStatusMt> for NavigationCapabilityStatus {
	fn from(p: crate::v2_5::types::NavigationCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::NavigationCapabilityStatusMt> for NavigationCapabilityStatus {
	fn into(self) -> crate::v2_5::types::NavigationCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the Navigation form of the general UCI Capability Command.  It is used to manually invoke a Navigation Capability to perform a new Navigation Activity or change an existing interactive Navigation Activity.  It differs from a Navigation Task because it is intended for direct interaction with the host of the Capability or a surrogate such as flight/vehicle management isolator.  Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages.  Capability Commands can be used in parallel with Tasks, but are generally deferential to them.  However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct NavigationCommand(
	pub crate::v2_5::types::NavigationCommandMt,
);
impl Deref for NavigationCommand {
	type Target = crate::v2_5::types::NavigationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for NavigationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::NavigationCommandMt> for NavigationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::NavigationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::NavigationCommandMt> for NavigationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::NavigationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::NavigationCommandMt> for NavigationCommand {
	fn from(p: crate::v2_5::types::NavigationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::NavigationCommandMt> for NavigationCommand {
	fn into(self) -> crate::v2_5::types::NavigationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of a NavigationCommand.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the NavigationActivity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct NavigationCommandStatus(
	pub crate::v2_5::types::NavigationCommandStatusMt,
);
impl Deref for NavigationCommandStatus {
	type Target = crate::v2_5::types::NavigationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for NavigationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::NavigationCommandStatusMt> for NavigationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::NavigationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::NavigationCommandStatusMt> for NavigationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::NavigationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::NavigationCommandStatusMt> for NavigationCommandStatus {
	fn from(p: crate::v2_5::types::NavigationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::NavigationCommandStatusMt> for NavigationCommandStatus {
	fn into(self) -> crate::v2_5::types::NavigationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the current navigation state of the System.  It is one of the "station-keeping" series of messages reported by most UCI Systems.  The station-keeping series is: PositionReport, SystemStatus, NavigationReport, [Capability]Status and [Capability]Activity.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct NavigationReport(
	pub crate::v2_5::types::NavigationReportMt,
);
impl Deref for NavigationReport {
	type Target = crate::v2_5::types::NavigationReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for NavigationReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::NavigationReportMt> for NavigationReport {
	fn as_ref(&self) -> &crate::v2_5::types::NavigationReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::NavigationReportMt> for NavigationReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::NavigationReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::NavigationReportMt> for NavigationReport {
	fn from(p: crate::v2_5::types::NavigationReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::NavigationReportMt> for NavigationReport {
	fn into(self) -> crate::v2_5::types::NavigationReportMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with a Navigation Capability.  Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct NavigationSettingsCommand(
	pub crate::v2_5::types::NavigationSettingsCommandMt,
);
impl Deref for NavigationSettingsCommand {
	type Target = crate::v2_5::types::NavigationSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for NavigationSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::NavigationSettingsCommandMt> for NavigationSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::NavigationSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::NavigationSettingsCommandMt> for NavigationSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::NavigationSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::NavigationSettingsCommandMt> for NavigationSettingsCommand {
	fn from(p: crate::v2_5::types::NavigationSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::NavigationSettingsCommandMt> for NavigationSettingsCommand {
	fn into(self) -> crate::v2_5::types::NavigationSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message reports the acknowledgment and/or acceptance of NavigationSettingsCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct NavigationSettingsCommandStatus(
	pub crate::v2_5::types::NavigationSettingsCommandStatusMt,
);
impl Deref for NavigationSettingsCommandStatus {
	type Target = crate::v2_5::types::NavigationSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for NavigationSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::NavigationSettingsCommandStatusMt> for NavigationSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::NavigationSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::NavigationSettingsCommandStatusMt> for NavigationSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::NavigationSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::NavigationSettingsCommandStatusMt> for NavigationSettingsCommandStatus {
	fn from(p: crate::v2_5::types::NavigationSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::NavigationSettingsCommandStatusMt> for NavigationSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::NavigationSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message represents an "OB correlation record". This is the correlated data, from either a Signal Report or Entity, that was potentially used to update an OB Record.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ObCorrelationRecord(
	pub crate::v2_5::types::ObCorrelationRecordMt,
);
impl Deref for ObCorrelationRecord {
	type Target = crate::v2_5::types::ObCorrelationRecordMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ObCorrelationRecord {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ObCorrelationRecordMt> for ObCorrelationRecord {
	fn as_ref(&self) -> &crate::v2_5::types::ObCorrelationRecordMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ObCorrelationRecordMt> for ObCorrelationRecord {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ObCorrelationRecordMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ObCorrelationRecordMt> for ObCorrelationRecord {
	fn from(p: crate::v2_5::types::ObCorrelationRecordMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ObCorrelationRecordMt> for ObCorrelationRecord {
	fn into(self) -> crate::v2_5::types::ObCorrelationRecordMt {
		self.0
	}
}


#[doc = r#"This message is used to provide kinematic measurement data/products from a sensor, along with associated data collected in tandem (e.g., per-measurement radar cross-section data) with the kinematic measurements. This message supports measurements for both known and unknown objects, and may optionally be associated with a known object.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ObservationMeasurementReport(
	pub crate::v2_5::types::ObservationMeasurementReportMt,
);
impl Deref for ObservationMeasurementReport {
	type Target = crate::v2_5::types::ObservationMeasurementReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ObservationMeasurementReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ObservationMeasurementReportMt> for ObservationMeasurementReport {
	fn as_ref(&self) -> &crate::v2_5::types::ObservationMeasurementReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ObservationMeasurementReportMt> for ObservationMeasurementReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ObservationMeasurementReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ObservationMeasurementReportMt> for ObservationMeasurementReport {
	fn from(p: crate::v2_5::types::ObservationMeasurementReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ObservationMeasurementReportMt> for ObservationMeasurementReport {
	fn into(self) -> crate::v2_5::types::ObservationMeasurementReportMt {
		self.0
	}
}


#[doc = r#"This message is used to provide 3rd party observation information about a known object. This message is meant to provide additional data on the object as observed by other than the object owner.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ObservationReport(
	pub crate::v2_5::types::ObservationReportMt,
);
impl Deref for ObservationReport {
	type Target = crate::v2_5::types::ObservationReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ObservationReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ObservationReportMt> for ObservationReport {
	fn as_ref(&self) -> &crate::v2_5::types::ObservationReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ObservationReportMt> for ObservationReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ObservationReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ObservationReportMt> for ObservationReport {
	fn from(p: crate::v2_5::types::ObservationReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ObservationReportMt> for ObservationReport {
	fn into(self) -> crate::v2_5::types::ObservationReportMt {
		self.0
	}
}


#[doc = r#"Indicates the track is an Opline, a predefined geospatial line.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OpLine(
	pub crate::v2_5::types::OpLineMt,
);
impl Deref for OpLine {
	type Target = crate::v2_5::types::OpLineMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OpLine {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OpLineMt> for OpLine {
	fn as_ref(&self) -> &crate::v2_5::types::OpLineMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OpLineMt> for OpLine {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OpLineMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OpLineMt> for OpLine {
	fn from(p: crate::v2_5::types::OpLineMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OpLineMt> for OpLine {
	fn into(self) -> crate::v2_5::types::OpLineMt {
		self.0
	}
}


#[doc = r#"This message contains notification information for an OpRouting, OpLine, OpPoint, OpVolume, or OpZone.
	Since the operational type(s) can be theater-wide and cross a set of mission plans and Systems, this could be the notification of an operational type(s) for one System or a set of Systems or all Systems. There could be different schedules for each system as well.
	An operational type(s) notification message could be only a partial notification for the whole operational type(s) based on System and schedule.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OpNotification(
	pub crate::v2_5::types::OpNotificationMt,
);
impl Deref for OpNotification {
	type Target = crate::v2_5::types::OpNotificationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OpNotification {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OpNotificationMt> for OpNotification {
	fn as_ref(&self) -> &crate::v2_5::types::OpNotificationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OpNotificationMt> for OpNotification {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OpNotificationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OpNotificationMt> for OpNotification {
	fn from(p: crate::v2_5::types::OpNotificationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OpNotificationMt> for OpNotification {
	fn into(self) -> crate::v2_5::types::OpNotificationMt {
		self.0
	}
}


#[doc = r#"This message represents a special class of points which may be taken into consideration by Services during their operation.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OpPoint(
	pub crate::v2_5::types::OpPointMt,
);
impl Deref for OpPoint {
	type Target = crate::v2_5::types::OpPointMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OpPoint {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OpPointMt> for OpPoint {
	fn as_ref(&self) -> &crate::v2_5::types::OpPointMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OpPointMt> for OpPoint {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OpPointMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OpPointMt> for OpPoint {
	fn from(p: crate::v2_5::types::OpPointMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OpPointMt> for OpPoint {
	fn into(self) -> crate::v2_5::types::OpPointMt {
		self.0
	}
}


#[doc = r#"This message represents routing constraints which may be taken into consideration by Systems and Services during their operation.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OpRouting(
	pub crate::v2_5::types::OpRoutingMt,
);
impl Deref for OpRouting {
	type Target = crate::v2_5::types::OpRoutingMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OpRouting {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OpRoutingMt> for OpRouting {
	fn as_ref(&self) -> &crate::v2_5::types::OpRoutingMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OpRoutingMt> for OpRouting {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OpRoutingMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OpRoutingMt> for OpRouting {
	fn from(p: crate::v2_5::types::OpRoutingMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OpRoutingMt> for OpRouting {
	fn into(self) -> crate::v2_5::types::OpRoutingMt {
		self.0
	}
}


#[doc = r#"This message contains a 3-dimensional operational volume that may be taken into consideration by services during their operation.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OpVolume(
	pub crate::v2_5::types::OpVolumeMt,
);
impl Deref for OpVolume {
	type Target = crate::v2_5::types::OpVolumeMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OpVolume {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OpVolumeMt> for OpVolume {
	fn as_ref(&self) -> &crate::v2_5::types::OpVolumeMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OpVolumeMt> for OpVolume {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OpVolumeMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OpVolumeMt> for OpVolume {
	fn from(p: crate::v2_5::types::OpVolumeMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OpVolumeMt> for OpVolume {
	fn into(self) -> crate::v2_5::types::OpVolumeMt {
		self.0
	}
}


#[doc = r#"This message represents a zone which may be taken into consideration by Services during their operation. Its primary use is airspace coordination.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OpZone(
	pub crate::v2_5::types::OpZoneMt,
);
impl Deref for OpZone {
	type Target = crate::v2_5::types::OpZoneMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OpZone {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OpZoneMt> for OpZone {
	fn as_ref(&self) -> &crate::v2_5::types::OpZoneMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OpZoneMt> for OpZone {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OpZoneMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OpZoneMt> for OpZone {
	fn from(p: crate::v2_5::types::OpZoneMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OpZoneMt> for OpZone {
	fn into(self) -> crate::v2_5::types::OpZoneMt {
		self.0
	}
}


#[doc = r#"This message represents the Opaque category of UCI Capability.  Opaque messages advertise the minimum set of parameters necessary for disclosing general status and limit capacities to updating subsystem settings by updating Mission Data Files (MDFs). Users of the Opaque Class of messages should only use the minimum set of fields necessary to satisfy subsystem and platform interactions.  The UCI Implementation is limited at this time to the OpaqueCapability and OpaqueSettingsCommand message pairs.   Opaque capabilities cannot be considered when using performing task allocation or route planning using the MissionPlanCommand message. Opaque capabilities should only be used when the type of payload cannot be published. Opaque capabilities should not be represented at different classification levels using the same CapabilityID. If the OpaqueCapability exists at the low level, and the same capability need to be represented at a higher level then the higher level would need its own CapabilityID and capability messages. This message "advertises" the mostly static characteristics of a mission-ready Opaque Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Manager  and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OpaqueCapability(
	pub crate::v2_5::types::OpaqueCapabilityMt,
);
impl Deref for OpaqueCapability {
	type Target = crate::v2_5::types::OpaqueCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OpaqueCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OpaqueCapabilityMt> for OpaqueCapability {
	fn as_ref(&self) -> &crate::v2_5::types::OpaqueCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OpaqueCapabilityMt> for OpaqueCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OpaqueCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OpaqueCapabilityMt> for OpaqueCapability {
	fn from(p: crate::v2_5::types::OpaqueCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OpaqueCapabilityMt> for OpaqueCapability {
	fn into(self) -> crate::v2_5::types::OpaqueCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Opaque capabilities available to the system. This message represents the Opaque category of UCI Capability.  Opaque messages advertise the minimum set of parameters necessary for disclosing general status and limit capacities to updating subsystem settings by updating Mission Data Files (MDFs). Users of the Opaque Class of messages should only use the minimum set of fields necessary to satisfy subsystem and platform interactions. The UCI Implementation is limited at this time to the OpaqueCapability and OpaqueSettingsCommand message pairs.   Opaque capabilities cannot be considered when using performing task allocation or route planning using the MissionPlanCommand message. Opaque capabilities should only be used when the type of payload cannot be published. Opaque capabilities should not be represented at different classification levels using the same CapabilityID. If the OpaqueCapability exists at the low level, and the same capability need to be represented at a higher level then the higher level would need its own CapabilityID and capability messages.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OpaqueCapabilityStatus(
	pub crate::v2_5::types::OpaqueCapabilityStatusMt,
);
impl Deref for OpaqueCapabilityStatus {
	type Target = crate::v2_5::types::OpaqueCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OpaqueCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OpaqueCapabilityStatusMt> for OpaqueCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OpaqueCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OpaqueCapabilityStatusMt> for OpaqueCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OpaqueCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OpaqueCapabilityStatusMt> for OpaqueCapabilityStatus {
	fn from(p: crate::v2_5::types::OpaqueCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OpaqueCapabilityStatusMt> for OpaqueCapabilityStatus {
	fn into(self) -> crate::v2_5::types::OpaqueCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the Opaque Capabilities of a Subsystem. This message represents the Opaque category of UCI Capability.  Opaque messages advertise the minimum set of parameters necessary for disclosing general status and limit capacities to updating subsystem settings by updating Mission Data Files (MDFs). Users of the Opaque Class of messages should only use the minimum set of fields necessary to satisfy subsystem and platform interactions. The UCI Implementation is limited at this time to the OpaqueCapability and OpaqueSettingsCommand message pairs.  SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Opaque capabilities cannot be considered when using performing task allocation or route planning using the MissionPlanCommand message. Opaque capabilities should only be used when the type of payload cannot be published. Opaque capabilities should not be represented at different classification levels using the same CapabilityID. If the OpaqueCapability exists at the low level, and the same capability need to be represented at a higher level then the higher level would need its own CapabilityID and capability messages.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OpaqueSettingsCommand(
	pub crate::v2_5::types::OpaqueSettingsCommandMt,
);
impl Deref for OpaqueSettingsCommand {
	type Target = crate::v2_5::types::OpaqueSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OpaqueSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OpaqueSettingsCommandMt> for OpaqueSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::OpaqueSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OpaqueSettingsCommandMt> for OpaqueSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OpaqueSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OpaqueSettingsCommandMt> for OpaqueSettingsCommand {
	fn from(p: crate::v2_5::types::OpaqueSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OpaqueSettingsCommandMt> for OpaqueSettingsCommand {
	fn into(self) -> crate::v2_5::types::OpaqueSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of an Opaque settings command. This message represents the Opaque category of UCI Capability.  Opaque messages advertise the minimum set of parameters necessary for disclosing general status and limit capacities to updating subsystem settings by updating Mission Data Files (MDFs). Users of the Opaque Class of messages should only use the minimum set of fields necessary to satisfy subsystem and platform interactions. The UCI Implementation is limited at this time to the OpaqueCapability and OpaqueSettingsCommand message pairs. Opaque capabilities cannot be considered when using performing task allocation or route planning using the MissionPlanCommand message. Opaque capabilities should only be used when the type of payload cannot be published. Opaque capabilities should not be represented at different classification levels using the same CapabilityID. If the OpaqueCapability exists at the low level, and the same capability need to be represented at a higher level then the higher level would need its own CapabilityID and capability messages.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OpaqueSettingsCommandStatus(
	pub crate::v2_5::types::OpaqueSettingsCommandStatusMt,
);
impl Deref for OpaqueSettingsCommandStatus {
	type Target = crate::v2_5::types::OpaqueSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OpaqueSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OpaqueSettingsCommandStatusMt> for OpaqueSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OpaqueSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OpaqueSettingsCommandStatusMt> for OpaqueSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OpaqueSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OpaqueSettingsCommandStatusMt> for OpaqueSettingsCommandStatus {
	fn from(p: crate::v2_5::types::OpaqueSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OpaqueSettingsCommandStatusMt> for OpaqueSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::OpaqueSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This messages provides details of a human operator associated with a System.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Operator(
	pub crate::v2_5::types::OperatorMt,
);
impl Deref for Operator {
	type Target = crate::v2_5::types::OperatorMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Operator {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OperatorMt> for Operator {
	fn as_ref(&self) -> &crate::v2_5::types::OperatorMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OperatorMt> for Operator {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OperatorMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OperatorMt> for Operator {
	fn from(p: crate::v2_5::types::OperatorMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OperatorMt> for Operator {
	fn into(self) -> crate::v2_5::types::OperatorMt {
		self.0
	}
}


#[doc = r#"This message is used by the operator to provide an action command in response to a notification with controlled actions. This message is meant to enable an operator to communicate information to a service.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OperatorActionCommand(
	pub crate::v2_5::types::OperatorActionCommandMt,
);
impl Deref for OperatorActionCommand {
	type Target = crate::v2_5::types::OperatorActionCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OperatorActionCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OperatorActionCommandMt> for OperatorActionCommand {
	fn as_ref(&self) -> &crate::v2_5::types::OperatorActionCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OperatorActionCommandMt> for OperatorActionCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OperatorActionCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OperatorActionCommandMt> for OperatorActionCommand {
	fn from(p: crate::v2_5::types::OperatorActionCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OperatorActionCommandMt> for OperatorActionCommand {
	fn into(self) -> crate::v2_5::types::OperatorActionCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the processing state of the indicated OperatorActionCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OperatorActionCommandStatus(
	pub crate::v2_5::types::OperatorActionCommandStatusMt,
);
impl Deref for OperatorActionCommandStatus {
	type Target = crate::v2_5::types::OperatorActionCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OperatorActionCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OperatorActionCommandStatusMt> for OperatorActionCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OperatorActionCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OperatorActionCommandStatusMt> for OperatorActionCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OperatorActionCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OperatorActionCommandStatusMt> for OperatorActionCommandStatus {
	fn from(p: crate::v2_5::types::OperatorActionCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OperatorActionCommandStatusMt> for OperatorActionCommandStatus {
	fn into(self) -> crate::v2_5::types::OperatorActionCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is intended to allow an operator a method to add notes and annotations during a mission. The contents of this message are intended to be recorded in a mission data log and not intended to be used to produce system or service responses.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OperatorAnnotation(
	pub crate::v2_5::types::OperatorAnnotationMt,
);
impl Deref for OperatorAnnotation {
	type Target = crate::v2_5::types::OperatorAnnotationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OperatorAnnotation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OperatorAnnotationMt> for OperatorAnnotation {
	fn as_ref(&self) -> &crate::v2_5::types::OperatorAnnotationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OperatorAnnotationMt> for OperatorAnnotation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OperatorAnnotationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OperatorAnnotationMt> for OperatorAnnotation {
	fn from(p: crate::v2_5::types::OperatorAnnotationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OperatorAnnotationMt> for OperatorAnnotation {
	fn into(self) -> crate::v2_5::types::OperatorAnnotationMt {
		self.0
	}
}


#[doc = r#"This message represents an operator- or other user -created geospatial location of interest that may be the precursor to a Task, Entity, etc.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OperatorLocationOfInterest(
	pub crate::v2_5::types::OperatorLocationOfInterestMt,
);
impl Deref for OperatorLocationOfInterest {
	type Target = crate::v2_5::types::OperatorLocationOfInterestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OperatorLocationOfInterest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OperatorLocationOfInterestMt> for OperatorLocationOfInterest {
	fn as_ref(&self) -> &crate::v2_5::types::OperatorLocationOfInterestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OperatorLocationOfInterestMt> for OperatorLocationOfInterest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OperatorLocationOfInterestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OperatorLocationOfInterestMt> for OperatorLocationOfInterest {
	fn from(p: crate::v2_5::types::OperatorLocationOfInterestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OperatorLocationOfInterestMt> for OperatorLocationOfInterest {
	fn into(self) -> crate::v2_5::types::OperatorLocationOfInterestMt {
		self.0
	}
}


#[doc = r#"This message is used to notify an operator of something that may require their attention.  It can be used to notify an operator that an error or issue is imminent; it is not assumed that this message represents an error that has occurred.  This message is meant for a service to communicate information to an operator display.  It is not to be used for machine to machine automation or to drive functionality directly.  Notifications that require machine action should be given via other messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OperatorNotification(
	pub crate::v2_5::types::OperatorNotificationMt,
);
impl Deref for OperatorNotification {
	type Target = crate::v2_5::types::OperatorNotificationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OperatorNotification {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OperatorNotificationMt> for OperatorNotification {
	fn as_ref(&self) -> &crate::v2_5::types::OperatorNotificationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OperatorNotificationMt> for OperatorNotification {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OperatorNotificationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OperatorNotificationMt> for OperatorNotification {
	fn from(p: crate::v2_5::types::OperatorNotificationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OperatorNotificationMt> for OperatorNotification {
	fn into(self) -> crate::v2_5::types::OperatorNotificationMt {
		self.0
	}
}


#[doc = r#"This message is used by an operator console to indicate an acknowledgment of a notification.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OperatorNotificationAck(
	pub crate::v2_5::types::OperatorNotificationAckMt,
);
impl Deref for OperatorNotificationAck {
	type Target = crate::v2_5::types::OperatorNotificationAckMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OperatorNotificationAck {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OperatorNotificationAckMt> for OperatorNotificationAck {
	fn as_ref(&self) -> &crate::v2_5::types::OperatorNotificationAckMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OperatorNotificationAckMt> for OperatorNotificationAck {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OperatorNotificationAckMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OperatorNotificationAckMt> for OperatorNotificationAck {
	fn from(p: crate::v2_5::types::OperatorNotificationAckMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OperatorNotificationAckMt> for OperatorNotificationAck {
	fn into(self) -> crate::v2_5::types::OperatorNotificationAckMt {
		self.0
	}
}


#[doc = r#"This message is used to indicate a notification override. Overridden (or disabled) notifications are suppressed by the system. This message is meant to be issued by an operator and received by the alert system.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OperatorNotificationOverride(
	pub crate::v2_5::types::OperatorNotificationOverrideMt,
);
impl Deref for OperatorNotificationOverride {
	type Target = crate::v2_5::types::OperatorNotificationOverrideMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OperatorNotificationOverride {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OperatorNotificationOverrideMt> for OperatorNotificationOverride {
	fn as_ref(&self) -> &crate::v2_5::types::OperatorNotificationOverrideMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OperatorNotificationOverrideMt> for OperatorNotificationOverride {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OperatorNotificationOverrideMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OperatorNotificationOverrideMt> for OperatorNotificationOverride {
	fn from(p: crate::v2_5::types::OperatorNotificationOverrideMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OperatorNotificationOverrideMt> for OperatorNotificationOverride {
	fn into(self) -> crate::v2_5::types::OperatorNotificationOverrideMt {
		self.0
	}
}


#[doc = r#"This messages defines an Operator Role such that it can be referenced within other messages and queried for.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OperatorRole(
	pub crate::v2_5::types::OperatorRoleMt,
);
impl Deref for OperatorRole {
	type Target = crate::v2_5::types::OperatorRoleMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OperatorRole {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OperatorRoleMt> for OperatorRole {
	fn as_ref(&self) -> &crate::v2_5::types::OperatorRoleMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OperatorRoleMt> for OperatorRole {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OperatorRoleMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OperatorRoleMt> for OperatorRole {
	fn from(p: crate::v2_5::types::OperatorRoleMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OperatorRoleMt> for OperatorRole {
	fn into(self) -> crate::v2_5::types::OperatorRoleMt {
		self.0
	}
}


#[doc = r#"This message specifies planned activities for a System with an OrbitPlan.  An "Orbit Activity" is any *Capability-related activity planned in context of the kinematic OrbitPlan of the System.  Activities are the planned implementation details of Effects, Actions, Tasks, Capability Commands, etc.  Orbit activity planning can be done manually by operators, by an activity planning service or a combination.  This message decouples activity planning from allocation, kinematic and other types of planning; the OrbitActivityPlan of a System can be created, updated and approved independent of other *Plans.  It enables any type of *Plan to be a constraint on activity planning.
An OrbitActivityPlan can be an input and/or output of planning processes.  For example an OrbitActivityPlan from a previous round of planning could be an input to an activity planning service that adds additional planned activities to it.
A single System can have multiple independent OrbitActivityPlans for different Task, Capability, sensor, etc. types; that are developed by one or more services across a multi-System service oriented architecture; at different times then independently updated and approved.  Optionally, all types of activities for a System can be included in a single OrbitActivityPlan.
An OrbitActivityPlan can be created discretely or as part of a MissionPlan that includes other *Plans.  An OrbitActivityPlan can only be activated and executed as part of a MissionPlan.  A MissionPlan can be used to plan the execution order of multiple OrbitActivityPlans and *Plans in general.  An OrbitActivityPlan can be subject to approval per Approval* messages.  Planning, approval, activation and execution state information for an OrbitActivityPlan are given in other OrbitActivityPlan* messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitActivityPlan(
	pub crate::v2_5::types::OrbitActivityPlanMt,
);
impl Deref for OrbitActivityPlan {
	type Target = crate::v2_5::types::OrbitActivityPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitActivityPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitActivityPlanMt> for OrbitActivityPlan {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitActivityPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitActivityPlanMt> for OrbitActivityPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitActivityPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitActivityPlanMt> for OrbitActivityPlan {
	fn from(p: crate::v2_5::types::OrbitActivityPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitActivityPlanMt> for OrbitActivityPlan {
	fn into(self) -> crate::v2_5::types::OrbitActivityPlanMt {
		self.0
	}
}


#[doc = r#"This message indicates state of approval for a OrbitActivityPlan.  Approval may or may not be required.  ApprovalPolicy aligned with the *Plans and states of planning allow a planning oversight authority to approve or reject plans as they're created or updated.  Approval may or may not be required.  If required, there may be many approvers.  See Approval* messages for additional details.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitActivityPlanApprovalStatus(
	pub crate::v2_5::types::OrbitActivityPlanApprovalStatusMt,
);
impl Deref for OrbitActivityPlanApprovalStatus {
	type Target = crate::v2_5::types::OrbitActivityPlanApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitActivityPlanApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitActivityPlanApprovalStatusMt> for OrbitActivityPlanApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitActivityPlanApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitActivityPlanApprovalStatusMt> for OrbitActivityPlanApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitActivityPlanApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitActivityPlanApprovalStatusMt> for OrbitActivityPlanApprovalStatus {
	fn from(p: crate::v2_5::types::OrbitActivityPlanApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitActivityPlanApprovalStatusMt> for OrbitActivityPlanApprovalStatus {
	fn into(self) -> crate::v2_5::types::OrbitActivityPlanApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message invokes an OrbitActivityPlan planning process.  Each planning process is declared with a unique ID in the ControlStatus message; that ID is used in this message to invoke the process.  The message includes many inputs to the planning process but many others may come from a variety of other messages.  A few examples of the many inputs include:
1. Options for constraining the planning function in a variety of ways using existing Plans of the same type or by other Plan types.  For example, an OrbitActivityPlan could be constrained by an existing kinematic OrbitPlan, a previous OrbitActivityPlan and/or a TaskPlan.
2. Environment overrides to selectively modify details of the current planning environment in the context of a single planning command. For example, a known threat Entity in the environment could be removed and an expected Entity could be for added to the environment in the context of a single planning command in support of "what-if" planning.
3. "Weightings" that influence the decisions of operators or planning algorithms performing the planning.
4. Temporal and/or kinematic begin and end points.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitActivityPlanCommand(
	pub crate::v2_5::types::OrbitActivityPlanCommandMt,
);
impl Deref for OrbitActivityPlanCommand {
	type Target = crate::v2_5::types::OrbitActivityPlanCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitActivityPlanCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitActivityPlanCommandMt> for OrbitActivityPlanCommand {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitActivityPlanCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitActivityPlanCommandMt> for OrbitActivityPlanCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitActivityPlanCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitActivityPlanCommandMt> for OrbitActivityPlanCommand {
	fn from(p: crate::v2_5::types::OrbitActivityPlanCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitActivityPlanCommandMt> for OrbitActivityPlanCommand {
	fn into(self) -> crate::v2_5::types::OrbitActivityPlanCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to create/update an OrbitActivityPlan, including the current state in a command and processing state machine; see the OrbitActivityPlanCommand message.  Creation/update of an OrbitActivityPlan  may occur autonomously, without an OrbitActivityPlanCommand in which case the current state of the plan could be given in the OrbitActivityPlanStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitActivityPlanCommandStatus(
	pub crate::v2_5::types::OrbitActivityPlanCommandStatusMt,
);
impl Deref for OrbitActivityPlanCommandStatus {
	type Target = crate::v2_5::types::OrbitActivityPlanCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitActivityPlanCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitActivityPlanCommandStatusMt> for OrbitActivityPlanCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitActivityPlanCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitActivityPlanCommandStatusMt> for OrbitActivityPlanCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitActivityPlanCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitActivityPlanCommandStatusMt> for OrbitActivityPlanCommandStatus {
	fn from(p: crate::v2_5::types::OrbitActivityPlanCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitActivityPlanCommandStatusMt> for OrbitActivityPlanCommandStatus {
	fn into(self) -> crate::v2_5::types::OrbitActivityPlanCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the current state in an execution state machine for one or more current and/or previous OrbitActivityPlans both as a whole and for individual Activities.  Plan execution begins after successful autonomous plan activation or activation via the MissionPlanActivation messages.  This message provides execution status regardless of how execution was initiated.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitActivityPlanExecutionStatus(
	pub crate::v2_5::types::OrbitActivityPlanExecutionStatusMt,
);
impl Deref for OrbitActivityPlanExecutionStatus {
	type Target = crate::v2_5::types::OrbitActivityPlanExecutionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitActivityPlanExecutionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitActivityPlanExecutionStatusMt> for OrbitActivityPlanExecutionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitActivityPlanExecutionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitActivityPlanExecutionStatusMt> for OrbitActivityPlanExecutionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitActivityPlanExecutionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitActivityPlanExecutionStatusMt> for OrbitActivityPlanExecutionStatus {
	fn from(p: crate::v2_5::types::OrbitActivityPlanExecutionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitActivityPlanExecutionStatusMt> for OrbitActivityPlanExecutionStatus {
	fn into(self) -> crate::v2_5::types::OrbitActivityPlanExecutionStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the current state in a planning and plan validation state machine for a OrbitActivityPlan.  Planning and validation may occur autonomously or be commanded.  In the former case, there is no command status message indicating the resulting state.  This message provides current status regardless of how status changes were triggered.  This message is not to be used to status individual actions within the OrbitActivityPlan, only the whole plan.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitActivityPlanStatus(
	pub crate::v2_5::types::OrbitActivityPlanStatusMt,
);
impl Deref for OrbitActivityPlanStatus {
	type Target = crate::v2_5::types::OrbitActivityPlanStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitActivityPlanStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitActivityPlanStatusMt> for OrbitActivityPlanStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitActivityPlanStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitActivityPlanStatusMt> for OrbitActivityPlanStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitActivityPlanStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitActivityPlanStatusMt> for OrbitActivityPlanStatus {
	fn from(p: crate::v2_5::types::OrbitActivityPlanStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitActivityPlanStatusMt> for OrbitActivityPlanStatus {
	fn into(self) -> crate::v2_5::types::OrbitActivityPlanStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the validation, including the current state in a validation state machine, and details of invalid items. Validation may occur periodically, or onesie twosie. See the OrbitActivityPlanValidationCommand message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitActivityPlanValidation(
	pub crate::v2_5::types::OrbitActivityPlanValidationMt,
);
impl Deref for OrbitActivityPlanValidation {
	type Target = crate::v2_5::types::OrbitActivityPlanValidationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitActivityPlanValidation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitActivityPlanValidationMt> for OrbitActivityPlanValidation {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitActivityPlanValidationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitActivityPlanValidationMt> for OrbitActivityPlanValidation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitActivityPlanValidationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitActivityPlanValidationMt> for OrbitActivityPlanValidation {
	fn from(p: crate::v2_5::types::OrbitActivityPlanValidationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitActivityPlanValidationMt> for OrbitActivityPlanValidation {
	fn into(self) -> crate::v2_5::types::OrbitActivityPlanValidationMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to validate/re-validate an existing OrbitActivityPlan.  It includes an option to modify the Plan to make it valid if it is found to be invalid.  A OrbitActivityPlan can become invalid due to changes in Task timing, space weather, order of battle, kinematic movement constraints, operator manual edits and many, many other reasons.  The message allows an existing OrbitActivityPlan to be checked for validity given such changes.  The variables a given planning service, operator or system considers when validating a plan varies.  Different variables might be considered depending on the level of detail of the plan or stage in the overall planning process.  The scope and meaning of "valid" comes from context of the services, operator and systems creating the plan.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitActivityPlanValidationCommand(
	pub crate::v2_5::types::OrbitActivityPlanValidationCommandMt,
);
impl Deref for OrbitActivityPlanValidationCommand {
	type Target = crate::v2_5::types::OrbitActivityPlanValidationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitActivityPlanValidationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitActivityPlanValidationCommandMt> for OrbitActivityPlanValidationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitActivityPlanValidationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitActivityPlanValidationCommandMt> for OrbitActivityPlanValidationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitActivityPlanValidationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitActivityPlanValidationCommandMt> for OrbitActivityPlanValidationCommand {
	fn from(p: crate::v2_5::types::OrbitActivityPlanValidationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitActivityPlanValidationCommandMt> for OrbitActivityPlanValidationCommand {
	fn into(self) -> crate::v2_5::types::OrbitActivityPlanValidationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to validate an OrbitActivityPlan, including the current state in a command and processing state machine.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitActivityPlanValidationCommandStatus(
	pub crate::v2_5::types::OrbitActivityPlanValidationCommandStatusMt,
);
impl Deref for OrbitActivityPlanValidationCommandStatus {
	type Target = crate::v2_5::types::OrbitActivityPlanValidationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitActivityPlanValidationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitActivityPlanValidationCommandStatusMt> for OrbitActivityPlanValidationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitActivityPlanValidationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitActivityPlanValidationCommandStatusMt> for OrbitActivityPlanValidationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitActivityPlanValidationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitActivityPlanValidationCommandStatusMt> for OrbitActivityPlanValidationCommandStatus {
	fn from(p: crate::v2_5::types::OrbitActivityPlanValidationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitActivityPlanValidationCommandStatusMt> for OrbitActivityPlanValidationCommandStatus {
	fn into(self) -> crate::v2_5::types::OrbitActivityPlanValidationCommandStatusMt {
		self.0
	}
}


#[doc = r#"A [Capability]Activity message describes what a Capability is actively doing. A [Capability]Capability message describes what a Subsystem is capable of doing if invoked; it is generally a complete, coherent snapshot of all Activities of a Subsystem for a Capability category (ESM, EA, etc.). In UCI terminology, an Activity is the dynamic, per-use status of a Capability. An Activity is an abstraction that includes the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability.  For the space domain, only Operational Level messages are provided.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitChangeActivity(
	pub crate::v2_5::types::OrbitChangeActivityMt,
);
impl Deref for OrbitChangeActivity {
	type Target = crate::v2_5::types::OrbitChangeActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitChangeActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitChangeActivityMt> for OrbitChangeActivity {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitChangeActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitChangeActivityMt> for OrbitChangeActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitChangeActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitChangeActivityMt> for OrbitChangeActivity {
	fn from(p: crate::v2_5::types::OrbitChangeActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitChangeActivityMt> for OrbitChangeActivity {
	fn into(self) -> crate::v2_5::types::OrbitChangeActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the Orbit Change category of UCI Capability.  It "advertises" the mostly static characteristics of a mission-ready Orbit Change Capability so that it can be "discovered" and used. "Discovery" can be a misnomer depending on your perspective. UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities. They don't eliminate the need for future software updates or configuration files. UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission. In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services. A [Capability]Capability message describes what a Subsystem is capable of doing if invoked. A [Capability]Activity message describes what a Capability is doing. Capabilities are aligned with end effects of Mission operations and for the Orbit Change Capability, it could be a proximity operation, a rendezvous or similar change.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitChangeCapability(
	pub crate::v2_5::types::OrbitChangeCapabilityMt,
);
impl Deref for OrbitChangeCapability {
	type Target = crate::v2_5::types::OrbitChangeCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitChangeCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitChangeCapabilityMt> for OrbitChangeCapability {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitChangeCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitChangeCapabilityMt> for OrbitChangeCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitChangeCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitChangeCapabilityMt> for OrbitChangeCapability {
	fn from(p: crate::v2_5::types::OrbitChangeCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitChangeCapabilityMt> for OrbitChangeCapability {
	fn into(self) -> crate::v2_5::types::OrbitChangeCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Orbit Change capabilities available to the system. This includes information regarding whether or not each capability is currently available based on hardware status, operational states, etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitChangeCapabilityStatus(
	pub crate::v2_5::types::OrbitChangeCapabilityStatusMt,
);
impl Deref for OrbitChangeCapabilityStatus {
	type Target = crate::v2_5::types::OrbitChangeCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitChangeCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitChangeCapabilityStatusMt> for OrbitChangeCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitChangeCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitChangeCapabilityStatusMt> for OrbitChangeCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitChangeCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitChangeCapabilityStatusMt> for OrbitChangeCapabilityStatus {
	fn from(p: crate::v2_5::types::OrbitChangeCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitChangeCapabilityStatusMt> for OrbitChangeCapabilityStatus {
	fn into(self) -> crate::v2_5::types::OrbitChangeCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message provides the details of an Orbit Conjunction Assessment. An Orbit  Conjunction can take several forms, including: collisions, near misses, RF interference and laser interference. An Orbit Conjunction Assessment may or may not be the result of a specific OrbitConjunctionAssessmentRequest; services could provide continuous assessment of the space domain and automatically provide conjunction information upon detection. A single message may report multiple conjunctions. Each Conjunction element only reports the interaction between two objects; if the assessment includes conjunctions between more than two objects, they must be organized into pairs.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitConjunctionAssessment(
	pub crate::v2_5::types::OrbitConjunctionAssessmentMt,
);
impl Deref for OrbitConjunctionAssessment {
	type Target = crate::v2_5::types::OrbitConjunctionAssessmentMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitConjunctionAssessment {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitConjunctionAssessmentMt> for OrbitConjunctionAssessment {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitConjunctionAssessmentMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitConjunctionAssessmentMt> for OrbitConjunctionAssessment {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitConjunctionAssessmentMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitConjunctionAssessmentMt> for OrbitConjunctionAssessment {
	fn from(p: crate::v2_5::types::OrbitConjunctionAssessmentMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitConjunctionAssessmentMt> for OrbitConjunctionAssessment {
	fn into(self) -> crate::v2_5::types::OrbitConjunctionAssessmentMt {
		self.0
	}
}


#[doc = r#"This message requests that a conjunction assessment be conducted using the defined objects. A request type can be as simple as comparing two distinct objects (SPECIFIED_ONLY), and as complex as assessing all known RSOs against all known RSOs (ALL_ON_ALL). The message may specify objects (e.g. a satellite), a Working (Space) Order of Battle (e.g. set of space objects), and/or a particular Debris Cloud.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitConjunctionAssessmentRequest(
	pub crate::v2_5::types::OrbitConjunctionAssessmentRequestMt,
);
impl Deref for OrbitConjunctionAssessmentRequest {
	type Target = crate::v2_5::types::OrbitConjunctionAssessmentRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitConjunctionAssessmentRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitConjunctionAssessmentRequestMt> for OrbitConjunctionAssessmentRequest {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitConjunctionAssessmentRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitConjunctionAssessmentRequestMt> for OrbitConjunctionAssessmentRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitConjunctionAssessmentRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitConjunctionAssessmentRequestMt> for OrbitConjunctionAssessmentRequest {
	fn from(p: crate::v2_5::types::OrbitConjunctionAssessmentRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitConjunctionAssessmentRequestMt> for OrbitConjunctionAssessmentRequest {
	fn into(self) -> crate::v2_5::types::OrbitConjunctionAssessmentRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status of an OrbitConjunctionAssessmentRequest received by the applicable C2 service. Upon completion of the assessment, the OrbitConjunctionAssessmentID should be provided.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitConjunctionAssessmentRequestStatus(
	pub crate::v2_5::types::OrbitConjunctionAssessmentRequestStatusMt,
);
impl Deref for OrbitConjunctionAssessmentRequestStatus {
	type Target = crate::v2_5::types::OrbitConjunctionAssessmentRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitConjunctionAssessmentRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitConjunctionAssessmentRequestStatusMt> for OrbitConjunctionAssessmentRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitConjunctionAssessmentRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitConjunctionAssessmentRequestStatusMt> for OrbitConjunctionAssessmentRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitConjunctionAssessmentRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitConjunctionAssessmentRequestStatusMt> for OrbitConjunctionAssessmentRequestStatus {
	fn from(p: crate::v2_5::types::OrbitConjunctionAssessmentRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitConjunctionAssessmentRequestStatusMt> for OrbitConjunctionAssessmentRequestStatus {
	fn into(self) -> crate::v2_5::types::OrbitConjunctionAssessmentRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message provides metrics on predicted performance details of an Orbit Plan and/or corresponding Orbit Action Plan. Metrics may be provided for any combination of parts for the Orbit Plan or Orbit Action Plan. Metrics include endurance and sub-categories include propulsion endurance, maneuverability endurance, and operational endurance. This message is intended for use prior to execution of a plan; for actual results of the plan, systems should use those status and activity messages produced during execution to derive metrics.
The intent of the *Plan Metrics messages are to provide calculated metrics that are based on existing plan input data. This is to continue the current paradigm of how metrics were represented in existing/previous MissionPlan and other sub plans. There is a distinction between the *Plan Metrics and the Assessment message, in that Assessment gives much more specific data and can consider other supporting systems and their capabilities in the assessment.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitMetrics(
	pub crate::v2_5::types::OrbitMetricsMt,
);
impl Deref for OrbitMetrics {
	type Target = crate::v2_5::types::OrbitMetricsMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitMetrics {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitMetricsMt> for OrbitMetrics {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitMetricsMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitMetricsMt> for OrbitMetrics {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitMetricsMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitMetricsMt> for OrbitMetrics {
	fn from(p: crate::v2_5::types::OrbitMetricsMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitMetricsMt> for OrbitMetrics {
	fn into(self) -> crate::v2_5::types::OrbitMetricsMt {
		self.0
	}
}


#[doc = r#"This message requests the generation of Orbit metrics for a specific orbit plan and, optionally, its associated orbit action plan and/or action parts. For details on what metrics are provided, see OrbitMetrics.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitMetricsRequest(
	pub crate::v2_5::types::OrbitMetricsRequestMt,
);
impl Deref for OrbitMetricsRequest {
	type Target = crate::v2_5::types::OrbitMetricsRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitMetricsRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitMetricsRequestMt> for OrbitMetricsRequest {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitMetricsRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitMetricsRequestMt> for OrbitMetricsRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitMetricsRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitMetricsRequestMt> for OrbitMetricsRequest {
	fn from(p: crate::v2_5::types::OrbitMetricsRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitMetricsRequestMt> for OrbitMetricsRequest {
	fn into(self) -> crate::v2_5::types::OrbitMetricsRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status of a OrbitMetricsRequest received by the applicable C2 system. In the event that metric reporting was incomplete, this message should provide details on why the process was unsuccessful.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitMetricsRequestStatus(
	pub crate::v2_5::types::OrbitMetricsRequestStatusMt,
);
impl Deref for OrbitMetricsRequestStatus {
	type Target = crate::v2_5::types::OrbitMetricsRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitMetricsRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitMetricsRequestStatusMt> for OrbitMetricsRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitMetricsRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitMetricsRequestStatusMt> for OrbitMetricsRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitMetricsRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitMetricsRequestStatusMt> for OrbitMetricsRequestStatus {
	fn from(p: crate::v2_5::types::OrbitMetricsRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitMetricsRequestStatusMt> for OrbitMetricsRequestStatus {
	fn into(self) -> crate::v2_5::types::OrbitMetricsRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message requests an orbit modification, which allows requests for atomic changes to an Orbit plan outside of normal mission/orbit planning, where transmission of whole plans could be an issue. The status of each request is reported in the OrbitModificationRequestStatus message. The result of a completed request is a new OrbitPlan message incorporating the modifications and incrementing the OrbitVersionID.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitModificationRequest(
	pub crate::v2_5::types::OrbitModificationRequestMt,
);
impl Deref for OrbitModificationRequest {
	type Target = crate::v2_5::types::OrbitModificationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitModificationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitModificationRequestMt> for OrbitModificationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitModificationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitModificationRequestMt> for OrbitModificationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitModificationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitModificationRequestMt> for OrbitModificationRequest {
	fn from(p: crate::v2_5::types::OrbitModificationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitModificationRequestMt> for OrbitModificationRequest {
	fn into(self) -> crate::v2_5::types::OrbitModificationRequestMt {
		self.0
	}
}


#[doc = r#"This is a message to report status on an OrbitModificationRequest. A successful modification request should result in a new OrbitPlan message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitModificationRequestStatus(
	pub crate::v2_5::types::OrbitModificationRequestStatusMt,
);
impl Deref for OrbitModificationRequestStatus {
	type Target = crate::v2_5::types::OrbitModificationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitModificationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitModificationRequestStatusMt> for OrbitModificationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitModificationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitModificationRequestStatusMt> for OrbitModificationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitModificationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitModificationRequestStatusMt> for OrbitModificationRequestStatus {
	fn from(p: crate::v2_5::types::OrbitModificationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitModificationRequestStatusMt> for OrbitModificationRequestStatus {
	fn into(self) -> crate::v2_5::types::OrbitModificationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies the planned kinematic details of a particular System's orbit; "orbit" is defined as a series of orbital element sets, ephemeris, vector covariance and/or explicit maneuvers between them.  The message is intended for Systems such as spacecraft whose kinematic plans are best represented in inertial/orbital frames.  Orbit planning can be done manually by operators, by a route planning service or a combination.  This message decouples kinematic planning from allocation, action and other types of planning; the kinematic OrbitPlan of a System can be created, updated and approved independent of other *Plans.  It enables any type of *Plan to be a constraint on route planning.
An OrbitPlan can be an input and/or output of planning processes.  For example a coarse OrbitPlan created by the top System in a hierarchical System of System for overall Mission orchestration and deconfliction could be an input to a orbit planning service that the produces a detailed, executable OrbitPlan for a specific subordinate System.
A single System can have multiple independent OrbitPlans for different orbit planning considerations such as orbit station keeping, orbital maneuvers and attitude adjustment.  The different planning considerations can be handled by one or more services across a multi-System service oriented architecture at different times then independently updated and approved.  Optionally, all kinematic orbit planning considerations for a System can be included in a single OrbitPlan.
An OrbitPlan can be created discretely or as part of a MissionPlan that includes other *Plans.  An OrbitPlan can only be activated and executed as part of a MissionPlan.  A MissionPlan can be used to plan the execution order of multiple OrbitPlans and *Plans in general.  An OrbitPlan can be subject to approval per Approval* messages.  Planning, approval, activation and execution state information for an OrbitPlan are given in other OrbitPlan* messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitPlan(
	pub crate::v2_5::types::OrbitPlanMt,
);
impl Deref for OrbitPlan {
	type Target = crate::v2_5::types::OrbitPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitPlanMt> for OrbitPlan {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitPlanMt> for OrbitPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitPlanMt> for OrbitPlan {
	fn from(p: crate::v2_5::types::OrbitPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitPlanMt> for OrbitPlan {
	fn into(self) -> crate::v2_5::types::OrbitPlanMt {
		self.0
	}
}


#[doc = r#"This message indicates status/state of approval for a OrbitPlan.  Approval may or may not be required.  ApprovalPolicy aligned with the *Plans and states of planning allow a planning oversight authority to approve or reject plans as they're created or updated.  Approval may or may not be required.  If required, there may be many approvers.  See Approval* messages for additional details.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitPlanApprovalStatus(
	pub crate::v2_5::types::OrbitPlanApprovalStatusMt,
);
impl Deref for OrbitPlanApprovalStatus {
	type Target = crate::v2_5::types::OrbitPlanApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitPlanApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitPlanApprovalStatusMt> for OrbitPlanApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitPlanApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitPlanApprovalStatusMt> for OrbitPlanApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitPlanApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitPlanApprovalStatusMt> for OrbitPlanApprovalStatus {
	fn from(p: crate::v2_5::types::OrbitPlanApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitPlanApprovalStatusMt> for OrbitPlanApprovalStatus {
	fn into(self) -> crate::v2_5::types::OrbitPlanApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message invokes an OrbitPlan planning process.  Each planning process is declared with a unique ID in the ControlStatus message; that ID is used in this message to invoke the process.  The message includes many inputs to the planning process but many others may come from a variety of other messages.  A few examples of the many inputs include:
1. Options for constraining the planning function in a variety of ways using existing Plans of the same type or by other Plan types.  For example, an OrbitPlan could be constrained by a previous OrbitPlan, a previous OrbitActivityPlan and/or a TaskPlan.
2. Environment overrides to selectively modify details of the current planning environment in the context of a single planning command. For example, a known threat Entity in the environment could be removed and an expected Entity could be added to the environment in the context of a single planning command in support of "what-if" planning.
3. "Weightings" that influence the decisions of operators or planning algorithms performing the planning.
4. Temporal and/or kinematic begin and end points.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitPlanCommand(
	pub crate::v2_5::types::OrbitPlanCommandMt,
);
impl Deref for OrbitPlanCommand {
	type Target = crate::v2_5::types::OrbitPlanCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitPlanCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitPlanCommandMt> for OrbitPlanCommand {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitPlanCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitPlanCommandMt> for OrbitPlanCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitPlanCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitPlanCommandMt> for OrbitPlanCommand {
	fn from(p: crate::v2_5::types::OrbitPlanCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitPlanCommandMt> for OrbitPlanCommand {
	fn into(self) -> crate::v2_5::types::OrbitPlanCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to create/update an OrbitPlan, including the current state in a command and processing state machine; see the OrbitPlanCommand message.  Creation/update of an OrbitPlan may occur autonomously, without an OrbitPlanCommand in which case the current state of the plan could be given in the RoutePlanStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitPlanCommandStatus(
	pub crate::v2_5::types::OrbitPlanCommandStatusMt,
);
impl Deref for OrbitPlanCommandStatus {
	type Target = crate::v2_5::types::OrbitPlanCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitPlanCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitPlanCommandStatusMt> for OrbitPlanCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitPlanCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitPlanCommandStatusMt> for OrbitPlanCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitPlanCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitPlanCommandStatusMt> for OrbitPlanCommandStatus {
	fn from(p: crate::v2_5::types::OrbitPlanCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitPlanCommandStatusMt> for OrbitPlanCommandStatus {
	fn into(self) -> crate::v2_5::types::OrbitPlanCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the execution status for one or more OrbitPlans.  Plan execution begins after successful autonomous plan activation or activation via MissionPlanActivation messages.  This message provides execution status regardless of how execution was initiated.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitPlanExecutionStatus(
	pub crate::v2_5::types::OrbitPlanExecutionStatusMt,
);
impl Deref for OrbitPlanExecutionStatus {
	type Target = crate::v2_5::types::OrbitPlanExecutionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitPlanExecutionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitPlanExecutionStatusMt> for OrbitPlanExecutionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitPlanExecutionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitPlanExecutionStatusMt> for OrbitPlanExecutionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitPlanExecutionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitPlanExecutionStatusMt> for OrbitPlanExecutionStatus {
	fn from(p: crate::v2_5::types::OrbitPlanExecutionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitPlanExecutionStatusMt> for OrbitPlanExecutionStatus {
	fn into(self) -> crate::v2_5::types::OrbitPlanExecutionStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the current state in a planning and plan validation state machine for an OrbitPlan.  Planning and validation may occur autonomously or be commanded.  In the former case, there is no command status message indicating the resulting state.  This message provides current status regardless of how status changes were triggered.  This message is not to be used to status individual actions within the OrbitPlan, only the whole plan.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitPlanStatus(
	pub crate::v2_5::types::OrbitPlanStatusMt,
);
impl Deref for OrbitPlanStatus {
	type Target = crate::v2_5::types::OrbitPlanStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitPlanStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitPlanStatusMt> for OrbitPlanStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitPlanStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitPlanStatusMt> for OrbitPlanStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitPlanStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitPlanStatusMt> for OrbitPlanStatus {
	fn from(p: crate::v2_5::types::OrbitPlanStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitPlanStatusMt> for OrbitPlanStatus {
	fn into(self) -> crate::v2_5::types::OrbitPlanStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the validation, including the current state in a validation state machine, and details of invalid items. Validation may occur periodically, or onesie twosie. See the OrbitPlanValidationCommand message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitPlanValidation(
	pub crate::v2_5::types::OrbitPlanValidationMt,
);
impl Deref for OrbitPlanValidation {
	type Target = crate::v2_5::types::OrbitPlanValidationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitPlanValidation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitPlanValidationMt> for OrbitPlanValidation {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitPlanValidationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitPlanValidationMt> for OrbitPlanValidation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitPlanValidationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitPlanValidationMt> for OrbitPlanValidation {
	fn from(p: crate::v2_5::types::OrbitPlanValidationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitPlanValidationMt> for OrbitPlanValidation {
	fn into(self) -> crate::v2_5::types::OrbitPlanValidationMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to validate/re-validate an existing OrbitPlan.  It includes an option to modify the Plan to make it valid if it is found to be invalid.  A OrbitPlan can become invalid due to changes in Task timing, weather, order of battle, kinematic movement constraints, operator manual edits and many, many other reasons.  The message allows an existing OrbitPlan to be checked for validity given such changes.  The variables a given planning service, operator or system considers when validating a plan varies.  Different variables might be considered depending on the level of detail of the plan or stage in the overall planning process.  The scope and meaning of "valid" comes from context of the services, operator and systems creating the plan.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitPlanValidationCommand(
	pub crate::v2_5::types::OrbitPlanValidationCommandMt,
);
impl Deref for OrbitPlanValidationCommand {
	type Target = crate::v2_5::types::OrbitPlanValidationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitPlanValidationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitPlanValidationCommandMt> for OrbitPlanValidationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitPlanValidationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitPlanValidationCommandMt> for OrbitPlanValidationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitPlanValidationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitPlanValidationCommandMt> for OrbitPlanValidationCommand {
	fn from(p: crate::v2_5::types::OrbitPlanValidationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitPlanValidationCommandMt> for OrbitPlanValidationCommand {
	fn into(self) -> crate::v2_5::types::OrbitPlanValidationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to validate an OrbitPlan, including the current state in a command and processing state machine.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitPlanValidationCommandStatus(
	pub crate::v2_5::types::OrbitPlanValidationCommandStatusMt,
);
impl Deref for OrbitPlanValidationCommandStatus {
	type Target = crate::v2_5::types::OrbitPlanValidationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitPlanValidationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitPlanValidationCommandStatusMt> for OrbitPlanValidationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitPlanValidationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitPlanValidationCommandStatusMt> for OrbitPlanValidationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitPlanValidationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitPlanValidationCommandStatusMt> for OrbitPlanValidationCommandStatus {
	fn from(p: crate::v2_5::types::OrbitPlanValidationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitPlanValidationCommandStatusMt> for OrbitPlanValidationCommandStatus {
	fn into(self) -> crate::v2_5::types::OrbitPlanValidationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message provides the details of an orbital debris assessment. Orbital debris is the result of one or more resident space objects (RSO) physically breaking into pieces. An orbital debris estimate may or may not be the result of a specific OrbitalDebrisEstimateRequest; services could provide continuous assessment of the space domain and automatically provide debris information. This message may either embed the results of the estimate directly, or reference a file containing the results. The estimate message provides details characterizing the debris cloud.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitalDebrisEstimate(
	pub crate::v2_5::types::OrbitalDebrisEstimateMt,
);
impl Deref for OrbitalDebrisEstimate {
	type Target = crate::v2_5::types::OrbitalDebrisEstimateMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitalDebrisEstimate {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitalDebrisEstimateMt> for OrbitalDebrisEstimate {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitalDebrisEstimateMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitalDebrisEstimateMt> for OrbitalDebrisEstimate {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitalDebrisEstimateMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitalDebrisEstimateMt> for OrbitalDebrisEstimate {
	fn from(p: crate::v2_5::types::OrbitalDebrisEstimateMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitalDebrisEstimateMt> for OrbitalDebrisEstimate {
	fn into(self) -> crate::v2_5::types::OrbitalDebrisEstimateMt {
		self.0
	}
}


#[doc = r#"This message requests the creation of a debris estimate for the defined objects. A request type can either refer to a conjunction assessment, two specific objects, or the breakup of a single object. The request also specifies the form the estimate may take; the estimate is either provided as a file or detailed within the OrbitalDebrisEstimate.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitalDebrisEstimateRequest(
	pub crate::v2_5::types::OrbitalDebrisEstimateRequestMt,
);
impl Deref for OrbitalDebrisEstimateRequest {
	type Target = crate::v2_5::types::OrbitalDebrisEstimateRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitalDebrisEstimateRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitalDebrisEstimateRequestMt> for OrbitalDebrisEstimateRequest {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitalDebrisEstimateRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitalDebrisEstimateRequestMt> for OrbitalDebrisEstimateRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitalDebrisEstimateRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitalDebrisEstimateRequestMt> for OrbitalDebrisEstimateRequest {
	fn from(p: crate::v2_5::types::OrbitalDebrisEstimateRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitalDebrisEstimateRequestMt> for OrbitalDebrisEstimateRequest {
	fn into(self) -> crate::v2_5::types::OrbitalDebrisEstimateRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status of an OrbitalDebrisEstimateRequest received by the applicable C2 service. Upon completion of the assessment, the OrbitalDebrisEstimateID should be provided.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitalDebrisEstimateRequestStatus(
	pub crate::v2_5::types::OrbitalDebrisEstimateRequestStatusMt,
);
impl Deref for OrbitalDebrisEstimateRequestStatus {
	type Target = crate::v2_5::types::OrbitalDebrisEstimateRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitalDebrisEstimateRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitalDebrisEstimateRequestStatusMt> for OrbitalDebrisEstimateRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitalDebrisEstimateRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitalDebrisEstimateRequestStatusMt> for OrbitalDebrisEstimateRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitalDebrisEstimateRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitalDebrisEstimateRequestStatusMt> for OrbitalDebrisEstimateRequestStatus {
	fn from(p: crate::v2_5::types::OrbitalDebrisEstimateRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitalDebrisEstimateRequestStatusMt> for OrbitalDebrisEstimateRequestStatus {
	fn into(self) -> crate::v2_5::types::OrbitalDebrisEstimateRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message describes the current activities being executed by an OrbitalSurveillance capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitalSurveillanceActivity(
	pub crate::v2_5::types::OrbitalSurveillanceActivityMt,
);
impl Deref for OrbitalSurveillanceActivity {
	type Target = crate::v2_5::types::OrbitalSurveillanceActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitalSurveillanceActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitalSurveillanceActivityMt> for OrbitalSurveillanceActivity {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitalSurveillanceActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitalSurveillanceActivityMt> for OrbitalSurveillanceActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitalSurveillanceActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitalSurveillanceActivityMt> for OrbitalSurveillanceActivity {
	fn from(p: crate::v2_5::types::OrbitalSurveillanceActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitalSurveillanceActivityMt> for OrbitalSurveillanceActivity {
	fn into(self) -> crate::v2_5::types::OrbitalSurveillanceActivityMt {
		self.0
	}
}


#[doc = r#"This message indicates that a subsystem is capable of performing an Orbital Surveillance activity. Orbital Surveillance involves the use of sensors of various different phenomenologies to search for and/or collect information on a target, multiple targets or region of space to meet a specific Information Objective.  The focus of an Orbital Surveillance activity (identified under the specification of Target) can be location based, object based, or zone based.
Examples of information objectives achieved through sensor collects include achieving or maintaining a certain level of orbit accuracy, verifying that there are no unknown objects in a specific region of space or with certain orbital parameters, determining the structural elements of a target down to a specified resolution, determining the current operational configuration of a target, or something as specific as providing a baseline characterization of a target in a specific phenomenology to be used for future change-detection.
This message advertises a subsystem's mostly static characteristics for a mission-ready Orbital Surveillance Capability to other systems, which enables proper commanding of the capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitalSurveillanceCapability(
	pub crate::v2_5::types::OrbitalSurveillanceCapabilityMt,
);
impl Deref for OrbitalSurveillanceCapability {
	type Target = crate::v2_5::types::OrbitalSurveillanceCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitalSurveillanceCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitalSurveillanceCapabilityMt> for OrbitalSurveillanceCapability {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitalSurveillanceCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitalSurveillanceCapabilityMt> for OrbitalSurveillanceCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitalSurveillanceCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitalSurveillanceCapabilityMt> for OrbitalSurveillanceCapability {
	fn from(p: crate::v2_5::types::OrbitalSurveillanceCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitalSurveillanceCapabilityMt> for OrbitalSurveillanceCapability {
	fn into(self) -> crate::v2_5::types::OrbitalSurveillanceCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Orbital Surveillance capabilities available to the system. This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitalSurveillanceCapabilityStatus(
	pub crate::v2_5::types::OrbitalSurveillanceCapabilityStatusMt,
);
impl Deref for OrbitalSurveillanceCapabilityStatus {
	type Target = crate::v2_5::types::OrbitalSurveillanceCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitalSurveillanceCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitalSurveillanceCapabilityStatusMt> for OrbitalSurveillanceCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitalSurveillanceCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitalSurveillanceCapabilityStatusMt> for OrbitalSurveillanceCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitalSurveillanceCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitalSurveillanceCapabilityStatusMt> for OrbitalSurveillanceCapabilityStatus {
	fn from(p: crate::v2_5::types::OrbitalSurveillanceCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitalSurveillanceCapabilityStatusMt> for OrbitalSurveillanceCapabilityStatus {
	fn into(self) -> crate::v2_5::types::OrbitalSurveillanceCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message describes the current activities being executed by an OrbitalSurveillanceSensor capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitalSurveillanceSensorActivity(
	pub crate::v2_5::types::OrbitalSurveillanceSensorActivityMt,
);
impl Deref for OrbitalSurveillanceSensorActivity {
	type Target = crate::v2_5::types::OrbitalSurveillanceSensorActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitalSurveillanceSensorActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitalSurveillanceSensorActivityMt> for OrbitalSurveillanceSensorActivity {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitalSurveillanceSensorActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitalSurveillanceSensorActivityMt> for OrbitalSurveillanceSensorActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitalSurveillanceSensorActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitalSurveillanceSensorActivityMt> for OrbitalSurveillanceSensorActivity {
	fn from(p: crate::v2_5::types::OrbitalSurveillanceSensorActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitalSurveillanceSensorActivityMt> for OrbitalSurveillanceSensorActivity {
	fn into(self) -> crate::v2_5::types::OrbitalSurveillanceSensorActivityMt {
		self.0
	}
}


#[doc = r#"This message contains information that a subsystem is capable of performing an Orbital Surveillance Sensor activity in the domain generally characterized by altitudes greater than 100 km above Earth's surface and less than interplanetary ranges. Orbital Surveillance Sensor involves the use of a single sensor to search for and/or collect information on a target, multiple targets or region of space to help meet a specific Information Objective.  The focus of an Orbital Surveillance Sensor activity (identified under the specification of Target) can be location based, object based, or zone based and targets can be in equilibrium orbits (affected only by natural forces) or under powered flight.
	Examples of information objectives achieved through sensor collects include achieving or maintaining a certain level of orbit accuracy, verifying that there are no unknown objects in a specific region of space or with certain orbital parameters, determining the structural elements of a target down to a specified resolution, determining the current operational configuration of a target, or something as specific as providing a baseline characterization of a target in a specific phenomenology to be used for future change-detection.
	This message advertises a subsystem's mostly static characteristics for a mission-ready Orbital Surveillance Sensor Capability to other systems, which enables proper commanding of the capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitalSurveillanceSensorCapability(
	pub crate::v2_5::types::OrbitalSurveillanceSensorCapabilityMt,
);
impl Deref for OrbitalSurveillanceSensorCapability {
	type Target = crate::v2_5::types::OrbitalSurveillanceSensorCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitalSurveillanceSensorCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitalSurveillanceSensorCapabilityMt> for OrbitalSurveillanceSensorCapability {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitalSurveillanceSensorCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitalSurveillanceSensorCapabilityMt> for OrbitalSurveillanceSensorCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitalSurveillanceSensorCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitalSurveillanceSensorCapabilityMt> for OrbitalSurveillanceSensorCapability {
	fn from(p: crate::v2_5::types::OrbitalSurveillanceSensorCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitalSurveillanceSensorCapabilityMt> for OrbitalSurveillanceSensorCapability {
	fn into(self) -> crate::v2_5::types::OrbitalSurveillanceSensorCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Orbital Surveillance Sensor capabilities available to the system. This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrbitalSurveillanceSensorCapabilityStatus(
	pub crate::v2_5::types::OrbitalSurveillanceSensorCapabilityStatusMt,
);
impl Deref for OrbitalSurveillanceSensorCapabilityStatus {
	type Target = crate::v2_5::types::OrbitalSurveillanceSensorCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrbitalSurveillanceSensorCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrbitalSurveillanceSensorCapabilityStatusMt> for OrbitalSurveillanceSensorCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrbitalSurveillanceSensorCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrbitalSurveillanceSensorCapabilityStatusMt> for OrbitalSurveillanceSensorCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrbitalSurveillanceSensorCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrbitalSurveillanceSensorCapabilityStatusMt> for OrbitalSurveillanceSensorCapabilityStatus {
	fn from(p: crate::v2_5::types::OrbitalSurveillanceSensorCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrbitalSurveillanceSensorCapabilityStatusMt> for OrbitalSurveillanceSensorCapabilityStatus {
	fn into(self) -> crate::v2_5::types::OrbitalSurveillanceSensorCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message contains a representation of an Order of Battle. An Order of Battle is an organizational structure defined as unit(s) and associated sites and equipment. An Order of Battle provides situational awareness as to units and the unit's primary purpose as well as the associated location or locations and equipment. An Order of Battle also includes the details of all known threats located in a particular volume or zone.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrderOfBattle(
	pub crate::v2_5::types::OrderOfBattleMt,
);
impl Deref for OrderOfBattle {
	type Target = crate::v2_5::types::OrderOfBattleMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrderOfBattle {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrderOfBattleMt> for OrderOfBattle {
	fn as_ref(&self) -> &crate::v2_5::types::OrderOfBattleMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrderOfBattleMt> for OrderOfBattle {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrderOfBattleMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrderOfBattleMt> for OrderOfBattle {
	fn from(p: crate::v2_5::types::OrderOfBattleMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrderOfBattleMt> for OrderOfBattle {
	fn into(self) -> crate::v2_5::types::OrderOfBattleMt {
		self.0
	}
}


#[doc = r#"This message requests creation of a new OrderOfBattle message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrderOfBattleRequest(
	pub crate::v2_5::types::OrderOfBattleRequestMt,
);
impl Deref for OrderOfBattleRequest {
	type Target = crate::v2_5::types::OrderOfBattleRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrderOfBattleRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrderOfBattleRequestMt> for OrderOfBattleRequest {
	fn as_ref(&self) -> &crate::v2_5::types::OrderOfBattleRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrderOfBattleRequestMt> for OrderOfBattleRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrderOfBattleRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrderOfBattleRequestMt> for OrderOfBattleRequest {
	fn from(p: crate::v2_5::types::OrderOfBattleRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrderOfBattleRequestMt> for OrderOfBattleRequest {
	fn into(self) -> crate::v2_5::types::OrderOfBattleRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to an OrderOfBattleRequest message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrderOfBattleRequestStatus(
	pub crate::v2_5::types::OrderOfBattleRequestStatusMt,
);
impl Deref for OrderOfBattleRequestStatus {
	type Target = crate::v2_5::types::OrderOfBattleRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrderOfBattleRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrderOfBattleRequestStatusMt> for OrderOfBattleRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::OrderOfBattleRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrderOfBattleRequestStatusMt> for OrderOfBattleRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrderOfBattleRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrderOfBattleRequestStatusMt> for OrderOfBattleRequestStatus {
	fn from(p: crate::v2_5::types::OrderOfBattleRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrderOfBattleRequestStatusMt> for OrderOfBattleRequestStatus {
	fn into(self) -> crate::v2_5::types::OrderOfBattleRequestStatusMt {
		self.0
	}
}


#[doc = r#"Indicates metadata for non-UCI orders such as an Air Tasking Order (ATO).  This message references an order or part of an order.  Other UCI messages can then reference this OrdersMetadata for orders traceability.  Some UCI messages that are aligned with concepts in non-UCI orders also include traceability.  For example, the UCI Mission message supports traceability to an ATO aircraft mission.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct OrdersMetadata(
	pub crate::v2_5::types::OrdersMetadataMt,
);
impl Deref for OrdersMetadata {
	type Target = crate::v2_5::types::OrdersMetadataMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for OrdersMetadata {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::OrdersMetadataMt> for OrdersMetadata {
	fn as_ref(&self) -> &crate::v2_5::types::OrdersMetadataMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::OrdersMetadataMt> for OrdersMetadata {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::OrdersMetadataMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::OrdersMetadataMt> for OrdersMetadata {
	fn from(p: crate::v2_5::types::OrdersMetadataMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::OrdersMetadataMt> for OrdersMetadata {
	fn into(self) -> crate::v2_5::types::OrdersMetadataMt {
		self.0
	}
}


#[doc = r#"This message indicates the existence of multi-System "packages" also known as "force packages", "strike packages", swarms, etc.  A Package is defined as a collection of Systems and their Capabilities that perform in concert to achieve results they can't achieve individually. For a given System in a Package, only those Capabilities defined in the message are included in the Package.  System Capabilities not included in the Package will behave as if the System was not part of the Package. Any functional change in the behavior of Systems and Capabilities due to inclusion in a Package may not be discoverable via UCI. Such differences are typically defined outside of the UCI schema. This message simply indicates the existence and configuration of the Package and is reported by a single lead or surrogate lead of the Package.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Package(
	pub crate::v2_5::types::PackageMt,
);
impl Deref for Package {
	type Target = crate::v2_5::types::PackageMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Package {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PackageMt> for Package {
	fn as_ref(&self) -> &crate::v2_5::types::PackageMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PackageMt> for Package {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PackageMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PackageMt> for Package {
	fn from(p: crate::v2_5::types::PackageMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PackageMt> for Package {
	fn into(self) -> crate::v2_5::types::PackageMt {
		self.0
	}
}


#[doc = r#"This message indicates the future status of a package in terms of its availability/readiness for a mission.  It might be reported by a surrogate if the given lead system can't report it when needed.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PackageReadiness(
	pub crate::v2_5::types::PackageReadinessMt,
);
impl Deref for PackageReadiness {
	type Target = crate::v2_5::types::PackageReadinessMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PackageReadiness {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PackageReadinessMt> for PackageReadiness {
	fn as_ref(&self) -> &crate::v2_5::types::PackageReadinessMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PackageReadinessMt> for PackageReadiness {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PackageReadinessMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PackageReadinessMt> for PackageReadiness {
	fn from(p: crate::v2_5::types::PackageReadinessMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PackageReadinessMt> for PackageReadiness {
	fn into(self) -> crate::v2_5::types::PackageReadinessMt {
		self.0
	}
}


#[doc = r#"This message indicates the status and configuration of a multi-System "package" (see PackageDefintion message for more details). Package status is intended to be reported by a single lead or surrogate lead of the package.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PackageStatus(
	pub crate::v2_5::types::PackageStatusMt,
);
impl Deref for PackageStatus {
	type Target = crate::v2_5::types::PackageStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PackageStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PackageStatusMt> for PackageStatus {
	fn as_ref(&self) -> &crate::v2_5::types::PackageStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PackageStatusMt> for PackageStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PackageStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PackageStatusMt> for PackageStatus {
	fn from(p: crate::v2_5::types::PackageStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PackageStatusMt> for PackageStatus {
	fn into(self) -> crate::v2_5::types::PackageStatusMt {
		self.0
	}
}


#[doc = r#"This message requests modification to a plan or set of plans. The status of the request is reported in the PlanModificationRequestStatus message. The result of a completed request is a new set of *Plan messages incorporating the modifications and incrementing the *PlanID.Version.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PlanModificationRequest(
	pub crate::v2_5::types::PlanModificationRequestMt,
);
impl Deref for PlanModificationRequest {
	type Target = crate::v2_5::types::PlanModificationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PlanModificationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PlanModificationRequestMt> for PlanModificationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::PlanModificationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PlanModificationRequestMt> for PlanModificationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PlanModificationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PlanModificationRequestMt> for PlanModificationRequest {
	fn from(p: crate::v2_5::types::PlanModificationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PlanModificationRequestMt> for PlanModificationRequest {
	fn into(self) -> crate::v2_5::types::PlanModificationRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status of a PlanModificationRequest received by the applicable C2 system. In the event that the modification was incomplete, this message should provide details on why the modification was unsuccessful. If successful, a new Plan message or messages should be sent out.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PlanModificationRequestStatus(
	pub crate::v2_5::types::PlanModificationRequestStatusMt,
);
impl Deref for PlanModificationRequestStatus {
	type Target = crate::v2_5::types::PlanModificationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PlanModificationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PlanModificationRequestStatusMt> for PlanModificationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::PlanModificationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PlanModificationRequestStatusMt> for PlanModificationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PlanModificationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PlanModificationRequestStatusMt> for PlanModificationRequestStatus {
	fn from(p: crate::v2_5::types::PlanModificationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PlanModificationRequestStatusMt> for PlanModificationRequestStatus {
	fn into(self) -> crate::v2_5::types::PlanModificationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message provides plan scoring against a set of operational constraints. Successful scoring requires that at least one of the provided plans utilized an OpConstraint Input; the score provided in PlanScores represents how well the produced plan conforms to the inputs. The specific performance requirements which constitute a 0 and 1 are defined by the scoring service. The message may either report the operational constraint scores of a single plan, or it may report an overall score of an operational constraint for a grouping of plans. If multiple plans require individual scoring then PlanScores messages are produced for each plan. Plan scores may or may not be produced as a result of a PlanScoresRequest message; some systems might produce score information automatically as part of their planning process.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PlanScores(
	pub crate::v2_5::types::PlanScoresMt,
);
impl Deref for PlanScores {
	type Target = crate::v2_5::types::PlanScoresMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PlanScores {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PlanScoresMt> for PlanScores {
	fn as_ref(&self) -> &crate::v2_5::types::PlanScoresMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PlanScoresMt> for PlanScores {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PlanScoresMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PlanScoresMt> for PlanScores {
	fn from(p: crate::v2_5::types::PlanScoresMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PlanScoresMt> for PlanScores {
	fn into(self) -> crate::v2_5::types::PlanScoresMt {
		self.0
	}
}


#[doc = r#"This message contains a request for a planning service to score plans against the specified operational constraints. This message can request scores for a single plan, or it may request an overall score for a group of plans. If multiple plans require individual scoring, a request must be made for each plan. This message provides information on the plan(s) to be scored and the operational constraints to use when calculating the plan scores. If an element is omitted, all constraints will be used. For details about what scores represent, see PlanScores.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PlanScoresRequest(
	pub crate::v2_5::types::PlanScoresRequestMt,
);
impl Deref for PlanScoresRequest {
	type Target = crate::v2_5::types::PlanScoresRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PlanScoresRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PlanScoresRequestMt> for PlanScoresRequest {
	fn as_ref(&self) -> &crate::v2_5::types::PlanScoresRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PlanScoresRequestMt> for PlanScoresRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PlanScoresRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PlanScoresRequestMt> for PlanScoresRequest {
	fn from(p: crate::v2_5::types::PlanScoresRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PlanScoresRequestMt> for PlanScoresRequest {
	fn into(self) -> crate::v2_5::types::PlanScoresRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status of a PlanScoresRequest received by the applicable C2 system. In the event that the scoring was incomplete, this message should provide details on why the scoring was unsuccessful.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PlanScoresRequestStatus(
	pub crate::v2_5::types::PlanScoresRequestStatusMt,
);
impl Deref for PlanScoresRequestStatus {
	type Target = crate::v2_5::types::PlanScoresRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PlanScoresRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PlanScoresRequestStatusMt> for PlanScoresRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::PlanScoresRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PlanScoresRequestStatusMt> for PlanScoresRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PlanScoresRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PlanScoresRequestStatusMt> for PlanScoresRequestStatus {
	fn from(p: crate::v2_5::types::PlanScoresRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PlanScoresRequestStatusMt> for PlanScoresRequestStatus {
	fn into(self) -> crate::v2_5::types::PlanScoresRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates all supported planning-related functions and interfaces of a System.  The closely related PlanningFunctionStatus message indicates how planning-related functions and interfaces of the System are currently configured.  Planning functions indicated here can be performed by human operators and/or machines/Services.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PlanningFunction(
	pub crate::v2_5::types::PlanningFunctionMt,
);
impl Deref for PlanningFunction {
	type Target = crate::v2_5::types::PlanningFunctionMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PlanningFunction {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PlanningFunctionMt> for PlanningFunction {
	fn as_ref(&self) -> &crate::v2_5::types::PlanningFunctionMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PlanningFunctionMt> for PlanningFunction {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PlanningFunctionMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PlanningFunctionMt> for PlanningFunction {
	fn from(p: crate::v2_5::types::PlanningFunctionMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PlanningFunctionMt> for PlanningFunction {
	fn into(self) -> crate::v2_5::types::PlanningFunctionMt {
		self.0
	}
}


#[doc = r#"This message changes the configuration of planning-related functions and interfaces of a System.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PlanningFunctionSettingsCommand(
	pub crate::v2_5::types::PlanningFunctionSettingsCommandMt,
);
impl Deref for PlanningFunctionSettingsCommand {
	type Target = crate::v2_5::types::PlanningFunctionSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PlanningFunctionSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PlanningFunctionSettingsCommandMt> for PlanningFunctionSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::PlanningFunctionSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PlanningFunctionSettingsCommandMt> for PlanningFunctionSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PlanningFunctionSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PlanningFunctionSettingsCommandMt> for PlanningFunctionSettingsCommand {
	fn from(p: crate::v2_5::types::PlanningFunctionSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PlanningFunctionSettingsCommandMt> for PlanningFunctionSettingsCommand {
	fn into(self) -> crate::v2_5::types::PlanningFunctionSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message provides transactional status for the PlanningFunctionsSettingsCommand message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PlanningFunctionSettingsCommandStatus(
	pub crate::v2_5::types::PlanningFunctionSettingsCommandStatusMt,
);
impl Deref for PlanningFunctionSettingsCommandStatus {
	type Target = crate::v2_5::types::PlanningFunctionSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PlanningFunctionSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PlanningFunctionSettingsCommandStatusMt> for PlanningFunctionSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::PlanningFunctionSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PlanningFunctionSettingsCommandStatusMt> for PlanningFunctionSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PlanningFunctionSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PlanningFunctionSettingsCommandStatusMt> for PlanningFunctionSettingsCommandStatus {
	fn from(p: crate::v2_5::types::PlanningFunctionSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PlanningFunctionSettingsCommandStatusMt> for PlanningFunctionSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::PlanningFunctionSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the configuration/status of currently enabled planning-related functions and interfaces of a System.  The closely related PlanningFunction message indicates all supported planning-related functions and interfaces.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PlanningFunctionStatus(
	pub crate::v2_5::types::PlanningFunctionStatusMt,
);
impl Deref for PlanningFunctionStatus {
	type Target = crate::v2_5::types::PlanningFunctionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PlanningFunctionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PlanningFunctionStatusMt> for PlanningFunctionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::PlanningFunctionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PlanningFunctionStatusMt> for PlanningFunctionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PlanningFunctionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PlanningFunctionStatusMt> for PlanningFunctionStatus {
	fn from(p: crate::v2_5::types::PlanningFunctionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PlanningFunctionStatusMt> for PlanningFunctionStatus {
	fn into(self) -> crate::v2_5::types::PlanningFunctionStatusMt {
		self.0
	}
}


#[doc = r#"A [Capability]Activity message describes what a Capability is doing. A [Capability]Capability message describes what a Subsystem is capable of doing if invoked; it is generally a complete, coherent snapshot of all Activities of a Subsystem for a Capability category (ESM, EA, etc.). This message indicates the combined in-work and to-do list of the PO Capability of a Subsystem of a System. In UCI terminology, an Activity is the dynamic, per-use status of a Capability. An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (PO_Command) from an Operator or Capability management Service, 3) currently in-work PO, 4) PO scheduled for the future and 5) PO that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons. A single PO_Command or other triggering event can result in multiple activities within the PO_Activity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PoActivity(
	pub crate::v2_5::types::PoActivityMt,
);
impl Deref for PoActivity {
	type Target = crate::v2_5::types::PoActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PoActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PoActivityMt> for PoActivity {
	fn as_ref(&self) -> &crate::v2_5::types::PoActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PoActivityMt> for PoActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PoActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PoActivityMt> for PoActivity {
	fn from(p: crate::v2_5::types::PoActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PoActivityMt> for PoActivity {
	fn into(self) -> crate::v2_5::types::PoActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the PO (Passive Optical which includes search and track) category of UCI Capability. This message "advertises" the mostly static characteristics of a mission-ready PO Capability (of a Subsystem of System) so that it can be "discovered" and used. "Discovery" can be a misnomer depending on your perspective. UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities. They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number. UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control. In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services. A [Capability]Capability message describes what a Subsystem is capable of doing if invoked. A [Capability]Activity message describes what a Capability is doing. Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others. Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages. Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform. Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PoCapability(
	pub crate::v2_5::types::PoCapabilityMt,
);
impl Deref for PoCapability {
	type Target = crate::v2_5::types::PoCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PoCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PoCapabilityMt> for PoCapability {
	fn as_ref(&self) -> &crate::v2_5::types::PoCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PoCapabilityMt> for PoCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PoCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PoCapabilityMt> for PoCapability {
	fn from(p: crate::v2_5::types::PoCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PoCapabilityMt> for PoCapability {
	fn into(self) -> crate::v2_5::types::PoCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the PO capabilities available to the system. This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PoCapabilityStatus(
	pub crate::v2_5::types::PoCapabilityStatusMt,
);
impl Deref for PoCapabilityStatus {
	type Target = crate::v2_5::types::PoCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PoCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PoCapabilityStatusMt> for PoCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::PoCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PoCapabilityStatusMt> for PoCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PoCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PoCapabilityStatusMt> for PoCapabilityStatus {
	fn from(p: crate::v2_5::types::PoCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PoCapabilityStatusMt> for PoCapabilityStatus {
	fn into(self) -> crate::v2_5::types::PoCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the PO (Passive Optical which includes search and track) form of the general UCI Capability Command. It is used to manually invoke a Passive Optical Capability to perform a new PO Activity or change an existing interactive PO Activity. It differs from a PO Task because it is intended for direct interaction with the host of the Capability, not a planning Service, and therefore is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan. Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages. Capability Commands can be used in parallel with Tasks, but are generally deferential to them. However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema. Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PoCommand(
	pub crate::v2_5::types::PoCommandMt,
);
impl Deref for PoCommand {
	type Target = crate::v2_5::types::PoCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PoCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PoCommandMt> for PoCommand {
	fn as_ref(&self) -> &crate::v2_5::types::PoCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PoCommandMt> for PoCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PoCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PoCommandMt> for PoCommand {
	fn from(p: crate::v2_5::types::PoCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PoCommandMt> for PoCommand {
	fn into(self) -> crate::v2_5::types::PoCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of a PO_Command. This message will reflect whether the command was received, accepted and/or rejected. This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled. The details of the specific activity or activities that result from the command will report status via the PO_Activity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PoCommandStatus(
	pub crate::v2_5::types::PoCommandStatusMt,
);
impl Deref for PoCommandStatus {
	type Target = crate::v2_5::types::PoCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PoCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PoCommandStatusMt> for PoCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::PoCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PoCommandStatusMt> for PoCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PoCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PoCommandStatusMt> for PoCommandStatus {
	fn from(p: crate::v2_5::types::PoCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PoCommandStatusMt> for PoCommandStatus {
	fn into(self) -> crate::v2_5::types::PoCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the PO Capabilities of a Subsystem. [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command. Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PoSettingsCommand(
	pub crate::v2_5::types::PoSettingsCommandMt,
);
impl Deref for PoSettingsCommand {
	type Target = crate::v2_5::types::PoSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PoSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PoSettingsCommandMt> for PoSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::PoSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PoSettingsCommandMt> for PoSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PoSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PoSettingsCommandMt> for PoSettingsCommand {
	fn from(p: crate::v2_5::types::PoSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PoSettingsCommandMt> for PoSettingsCommand {
	fn into(self) -> crate::v2_5::types::PoSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message reports the receipt, acceptance, or rejection of its corresponding PO_SettingsCommand message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PoSettingsCommandStatus(
	pub crate::v2_5::types::PoSettingsCommandStatusMt,
);
impl Deref for PoSettingsCommandStatus {
	type Target = crate::v2_5::types::PoSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PoSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PoSettingsCommandStatusMt> for PoSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::PoSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PoSettingsCommandStatusMt> for PoSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PoSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PoSettingsCommandStatusMt> for PoSettingsCommandStatus {
	fn from(p: crate::v2_5::types::PoSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PoSettingsCommandStatusMt> for PoSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::PoSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the location and speed of a System or Resource.  It is analogous to a simplified MIL-STD-6016 PPLI message.  It is one of the "station-keeping" series of messages reported by most UCI Systems.  The station-keeping series includes PositionReport, SystemStatus, NavigationReport, [Capability]Status and [Capability]Activity.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PositionReport(
	pub crate::v2_5::types::PositionReportMt,
);
impl Deref for PositionReport {
	type Target = crate::v2_5::types::PositionReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PositionReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PositionReportMt> for PositionReport {
	fn as_ref(&self) -> &crate::v2_5::types::PositionReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PositionReportMt> for PositionReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PositionReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PositionReportMt> for PositionReport {
	fn from(p: crate::v2_5::types::PositionReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PositionReportMt> for PositionReport {
	fn into(self) -> crate::v2_5::types::PositionReportMt {
		self.0
	}
}


#[doc = r#"This message indicates the location, speed, and direction of a System or Resource. It is not one of the "station-keeping" series of messages, but is designed to provide positional information at a much higher frequency than PositionReport, and allows for multiple redundant systems to provide reports in the same message.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PositionReportDetailed(
	pub crate::v2_5::types::PositionReportDetailedMt,
);
impl Deref for PositionReportDetailed {
	type Target = crate::v2_5::types::PositionReportDetailedMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PositionReportDetailed {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PositionReportDetailedMt> for PositionReportDetailed {
	fn as_ref(&self) -> &crate::v2_5::types::PositionReportDetailedMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PositionReportDetailedMt> for PositionReportDetailed {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PositionReportDetailedMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PositionReportDetailedMt> for PositionReportDetailed {
	fn from(p: crate::v2_5::types::PositionReportDetailedMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PositionReportDetailedMt> for PositionReportDetailed {
	fn into(self) -> crate::v2_5::types::PositionReportDetailedMt {
		self.0
	}
}


#[doc = r#"This message represents a list of battlespace objects or actors, prioritized for an enumerated purpose or perspective.  It establishes an order/priority by which objects should be addressed/processed.  This message has a spectrum of possible uses from the very broad focused to the very narrowly focused.  For example, it could be used broadly to establish the priority of threats/targets as general guidance to all of the Systems in a System of Systems, agnostic of their individual Missions, Capabilities or Services.   Alternatively, it could be very narrowly focused to establish a different priority of threats/targets for each phase of F2T2EA, filtered/tailored by System, Service, time or space.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PrioritizationList(
	pub crate::v2_5::types::PrioritizationListMt,
);
impl Deref for PrioritizationList {
	type Target = crate::v2_5::types::PrioritizationListMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PrioritizationList {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PrioritizationListMt> for PrioritizationList {
	fn as_ref(&self) -> &crate::v2_5::types::PrioritizationListMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PrioritizationListMt> for PrioritizationList {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PrioritizationListMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PrioritizationListMt> for PrioritizationList {
	fn from(p: crate::v2_5::types::PrioritizationListMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PrioritizationListMt> for PrioritizationList {
	fn into(self) -> crate::v2_5::types::PrioritizationListMt {
		self.0
	}
}


#[doc = r#"This message indicates the current system rules for determining which products are eligible for automatic download.
Downloads can be manually planned and requested on a task by task basis utilizing the Download Task and Download Request.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductDownloadPlan(
	pub crate::v2_5::types::ProductDownloadPlanMt,
);
impl Deref for ProductDownloadPlan {
	type Target = crate::v2_5::types::ProductDownloadPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductDownloadPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductDownloadPlanMt> for ProductDownloadPlan {
	fn as_ref(&self) -> &crate::v2_5::types::ProductDownloadPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductDownloadPlanMt> for ProductDownloadPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductDownloadPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductDownloadPlanMt> for ProductDownloadPlan {
	fn from(p: crate::v2_5::types::ProductDownloadPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductDownloadPlanMt> for ProductDownloadPlan {
	fn into(self) -> crate::v2_5::types::ProductDownloadPlanMt {
		self.0
	}
}


#[doc = r#"This message is used to report (via publish/broadcast) that a product has been downloaded.  It is primarily for operator SA.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductDownloadReport(
	pub crate::v2_5::types::ProductDownloadReportMt,
);
impl Deref for ProductDownloadReport {
	type Target = crate::v2_5::types::ProductDownloadReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductDownloadReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductDownloadReportMt> for ProductDownloadReport {
	fn as_ref(&self) -> &crate::v2_5::types::ProductDownloadReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductDownloadReportMt> for ProductDownloadReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductDownloadReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductDownloadReportMt> for ProductDownloadReport {
	fn from(p: crate::v2_5::types::ProductDownloadReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductDownloadReportMt> for ProductDownloadReport {
	fn into(self) -> crate::v2_5::types::ProductDownloadReportMt {
		self.0
	}
}


#[doc = r#"This message is a request that a file or files to be downloaded.  In some cases, a product may reside on a system in a location that is not reachable by other UCI services via a network URI.  This message is intended to request that a product be downloaded to a location where other services can reach it via a network URI.  An example of this is a product that has been stored on-board a vehicle but has not been downloaded.

A Product Download Request directly invokes functionality to download a product.  Execution of the download request would result in a Product Download Request Status followed by a Product Download Report.

There are 2 ways this message can be generated.  1.) By the operator to command immediate download of a product.  2.) Automated by a service as a result of execution of a Download Task.

If automatically generated as a result of Download Task execution, the download requirements would be populated with those specified in the Download Task.  This allows the default plan to be overridden on a task by task basis.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductDownloadRequest(
	pub crate::v2_5::types::ProductDownloadRequestMt,
);
impl Deref for ProductDownloadRequest {
	type Target = crate::v2_5::types::ProductDownloadRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductDownloadRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductDownloadRequestMt> for ProductDownloadRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ProductDownloadRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductDownloadRequestMt> for ProductDownloadRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductDownloadRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductDownloadRequestMt> for ProductDownloadRequest {
	fn from(p: crate::v2_5::types::ProductDownloadRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductDownloadRequestMt> for ProductDownloadRequest {
	fn into(self) -> crate::v2_5::types::ProductDownloadRequestMt {
		self.0
	}
}


#[doc = r#"This message provides status for a previously submitted ProductDownloadRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductDownloadRequestStatus(
	pub crate::v2_5::types::ProductDownloadRequestStatusMt,
);
impl Deref for ProductDownloadRequestStatus {
	type Target = crate::v2_5::types::ProductDownloadRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductDownloadRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductDownloadRequestStatusMt> for ProductDownloadRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ProductDownloadRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductDownloadRequestStatusMt> for ProductDownloadRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductDownloadRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductDownloadRequestStatusMt> for ProductDownloadRequestStatus {
	fn from(p: crate::v2_5::types::ProductDownloadRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductDownloadRequestStatusMt> for ProductDownloadRequestStatus {
	fn into(self) -> crate::v2_5::types::ProductDownloadRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is a task that a file or files is to be downloaded.
Download Tasks do not directly invoke functionality.  They are utilized to schedule post-collection download of products.  As a result, it is expected that a Product Download Task would typically specify a collection task as a preceding dependent task.

Execution of a Download Task would result in issue of a Download Request to invoke download service functionality.

This message can be used to override the ProductDownloadPlan on a task by task basis.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductDownloadTask(
	pub crate::v2_5::types::ProductDownloadTaskMt,
);
impl Deref for ProductDownloadTask {
	type Target = crate::v2_5::types::ProductDownloadTaskMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductDownloadTask {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductDownloadTaskMt> for ProductDownloadTask {
	fn as_ref(&self) -> &crate::v2_5::types::ProductDownloadTaskMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductDownloadTaskMt> for ProductDownloadTask {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductDownloadTaskMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductDownloadTaskMt> for ProductDownloadTask {
	fn from(p: crate::v2_5::types::ProductDownloadTaskMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductDownloadTaskMt> for ProductDownloadTask {
	fn into(self) -> crate::v2_5::types::ProductDownloadTaskMt {
		self.0
	}
}


#[doc = r#"This message provides status for a task that a file or files is to be downloaded.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductDownloadTaskStatus(
	pub crate::v2_5::types::ProductDownloadTaskStatusMt,
);
impl Deref for ProductDownloadTaskStatus {
	type Target = crate::v2_5::types::ProductDownloadTaskStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductDownloadTaskStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductDownloadTaskStatusMt> for ProductDownloadTaskStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ProductDownloadTaskStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductDownloadTaskStatusMt> for ProductDownloadTaskStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductDownloadTaskStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductDownloadTaskStatusMt> for ProductDownloadTaskStatus {
	fn from(p: crate::v2_5::types::ProductDownloadTaskStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductDownloadTaskStatusMt> for ProductDownloadTaskStatus {
	fn into(self) -> crate::v2_5::types::ProductDownloadTaskStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies the network location of a product.  See the annotations for ProductMetadata for an explanation of how it works together with this message.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductLocation(
	pub crate::v2_5::types::ProductLocationMt,
);
impl Deref for ProductLocation {
	type Target = crate::v2_5::types::ProductLocationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductLocation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductLocationMt> for ProductLocation {
	fn as_ref(&self) -> &crate::v2_5::types::ProductLocationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductLocationMt> for ProductLocation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductLocationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductLocationMt> for ProductLocation {
	fn from(p: crate::v2_5::types::ProductLocationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductLocationMt> for ProductLocation {
	fn into(self) -> crate::v2_5::types::ProductLocationMt {
		self.0
	}
}


#[doc = r#"This message specifies UCI relevant metadata for a Product.  The term "Product" generally refers to an output of a Capability (SAR, PO, etc.) whose content and format are specified outside of the UCI standard.  A Product could be a file, digital stream, analog video, etc.  ProductMetadata and ProductLocation shouldn't be used for things that aren't Capability outputs.   It does not contain actual products nor does it specify their network location.  Network location is published in the ProductLocation message.  "Metadata" includes a summary of geospatial, time, classification, file name, file format and other characteristics of the product.  It also includes optional Task and/or [Capability]Command  specific metadata that link the product to the task or command that created it.  The optional Thumbnail element can be used in conjunction with the ProductLocation message to preview the product.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductMetadata(
	pub crate::v2_5::types::ProductMetadataMt,
);
impl Deref for ProductMetadata {
	type Target = crate::v2_5::types::ProductMetadataMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductMetadata {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductMetadataMt> for ProductMetadata {
	fn as_ref(&self) -> &crate::v2_5::types::ProductMetadataMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductMetadataMt> for ProductMetadata {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductMetadataMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductMetadataMt> for ProductMetadata {
	fn from(p: crate::v2_5::types::ProductMetadataMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductMetadataMt> for ProductMetadata {
	fn into(self) -> crate::v2_5::types::ProductMetadataMt {
		self.0
	}
}


#[doc = r#"This message indicates the default system rules for determining at which classification a product or file should be labeled.  Classification labeling can happen in 3 ways.

1.) Classification is specified as part of the collection task.  This method is used to tell the sensor subsystem to label the product or file with classification as part of product or file creation.  When this method is used, the Product Or File Classification Plan can be used to determine the classification of the collection task based on the filter criteria such as zone or time.

2.) The operator creates a Product Or File Classification Task to perform post-collect, post-download classification (or reclassification) of a product or file.  With this method, the operator can choose to classify based on the Product Or File Classification Plan or can override the plan by specifying a classification.

3.) The classification of a product generated from product processing does not directly use this plan to determine classification.  The default behavior would be for the processing function to classify the new product with the highest classification of the new product's parent products.  The operator has the ability to override this default behavior using the ProcessingTask and ProcessingRequest messages.  If any post-creation classification/reclassification of processed products is desired, method 2 described above should be utilized.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileClassificationPlan(
	pub crate::v2_5::types::ProductOrFileClassificationPlanMt,
);
impl Deref for ProductOrFileClassificationPlan {
	type Target = crate::v2_5::types::ProductOrFileClassificationPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileClassificationPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileClassificationPlanMt> for ProductOrFileClassificationPlan {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileClassificationPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileClassificationPlanMt> for ProductOrFileClassificationPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileClassificationPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileClassificationPlanMt> for ProductOrFileClassificationPlan {
	fn from(p: crate::v2_5::types::ProductOrFileClassificationPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileClassificationPlanMt> for ProductOrFileClassificationPlan {
	fn into(self) -> crate::v2_5::types::ProductOrFileClassificationPlanMt {
		self.0
	}
}


#[doc = r#"This message provides a report of the classification of a product or file.  It has 2 primary uses:
1.)  To report (via publish/broadcast) the state of a product or file classification.  This is primarily for operator SA and is extremely useful for providing insight into dynamic classification such as changes of streaming products.  For example, a change in classification of an EOIR stream resulting from a Product Or File Classification Plan zone transition.

2.)  For persistence of state to support initialization and recovery of a service that is applying security labels to products or files.  This allows for a service to retrieve the classification label of a product or file upon initialization.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileClassificationReport(
	pub crate::v2_5::types::ProductOrFileClassificationReportMt,
);
impl Deref for ProductOrFileClassificationReport {
	type Target = crate::v2_5::types::ProductOrFileClassificationReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileClassificationReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileClassificationReportMt> for ProductOrFileClassificationReport {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileClassificationReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileClassificationReportMt> for ProductOrFileClassificationReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileClassificationReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileClassificationReportMt> for ProductOrFileClassificationReport {
	fn from(p: crate::v2_5::types::ProductOrFileClassificationReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileClassificationReportMt> for ProductOrFileClassificationReport {
	fn into(self) -> crate::v2_5::types::ProductOrFileClassificationReportMt {
		self.0
	}
}


#[doc = r#"This message has 2 uses.
Message use 1:

This message is a request that a product or file be classified at a particular level.

A Product Or File Classification Request directly invokes classification service functionality to classify/reclassify a product or file.  Execution of the classification request would result in a Product Or File Classification Request Status followed by a Product Or File Classification Report.

There are 2 ways this message can be generated.  1.) By the operator to command immediate reclassification of a product or file.  2.) Automated by a service as a result of execution of a Classification Task.

When specifying a Classification Request, the user can choose to utilize the Product or File Classification Plan to determine classification or can override the plan by specifying a classification.

If automatically generated as a result of Classification Task execution, the classification requirements would be populated with those specified in the Classification Task.  This allows the default plan to be utilized or overridden on a task by task basis.

Message use 2:

This message requests that a classification label is generated per the Product Or File Classification Plan and returned in the Product Or File Classification Request Status.  When the message is used in this way, the classification should be omitted from the Classification Requirements.  This message use allows for a service decomposition where the service applying the classification label is separate from the service that determines classification based on the classification plan.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileClassificationRequest(
	pub crate::v2_5::types::ProductOrFileClassificationRequestMt,
);
impl Deref for ProductOrFileClassificationRequest {
	type Target = crate::v2_5::types::ProductOrFileClassificationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileClassificationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileClassificationRequestMt> for ProductOrFileClassificationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileClassificationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileClassificationRequestMt> for ProductOrFileClassificationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileClassificationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileClassificationRequestMt> for ProductOrFileClassificationRequest {
	fn from(p: crate::v2_5::types::ProductOrFileClassificationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileClassificationRequestMt> for ProductOrFileClassificationRequest {
	fn into(self) -> crate::v2_5::types::ProductOrFileClassificationRequestMt {
		self.0
	}
}


#[doc = r#"This message provides status for a previously submitted ProductOrFileClassificationRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileClassificationRequestStatus(
	pub crate::v2_5::types::ProductOrFileClassificationRequestStatusMt,
);
impl Deref for ProductOrFileClassificationRequestStatus {
	type Target = crate::v2_5::types::ProductOrFileClassificationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileClassificationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileClassificationRequestStatusMt> for ProductOrFileClassificationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileClassificationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileClassificationRequestStatusMt> for ProductOrFileClassificationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileClassificationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileClassificationRequestStatusMt> for ProductOrFileClassificationRequestStatus {
	fn from(p: crate::v2_5::types::ProductOrFileClassificationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileClassificationRequestStatusMt> for ProductOrFileClassificationRequestStatus {
	fn into(self) -> crate::v2_5::types::ProductOrFileClassificationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message represents a task for a product or file to be classified at a particular level.  Classification Tasks do not directly invoke functionality.  They are utilized to schedule post-collection and post-download classification/reclassification of products or files.  As a result, it is expected that a Product Or File Classification Task would typically specify a download and/or collection task as a preceding dependent task.  Execution of a Classification Task would result in issue of a Classification Request to invoke classification service functionality.  When specifying a Classification Task, the user can choose to utilize the Product Or File Classification Plan to determine classification or can override the plan by specifying a classification.  This allows the default plan to be overridden on a Task by Task basis.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileClassificationTask(
	pub crate::v2_5::types::ProductOrFileClassificationTaskMt,
);
impl Deref for ProductOrFileClassificationTask {
	type Target = crate::v2_5::types::ProductOrFileClassificationTaskMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileClassificationTask {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileClassificationTaskMt> for ProductOrFileClassificationTask {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileClassificationTaskMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileClassificationTaskMt> for ProductOrFileClassificationTask {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileClassificationTaskMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileClassificationTaskMt> for ProductOrFileClassificationTask {
	fn from(p: crate::v2_5::types::ProductOrFileClassificationTaskMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileClassificationTaskMt> for ProductOrFileClassificationTask {
	fn into(self) -> crate::v2_5::types::ProductOrFileClassificationTaskMt {
		self.0
	}
}


#[doc = r#"This message provides the status of a Classification Task.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileClassificationTaskStatus(
	pub crate::v2_5::types::ProductOrFileClassificationTaskStatusMt,
);
impl Deref for ProductOrFileClassificationTaskStatus {
	type Target = crate::v2_5::types::ProductOrFileClassificationTaskStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileClassificationTaskStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileClassificationTaskStatusMt> for ProductOrFileClassificationTaskStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileClassificationTaskStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileClassificationTaskStatusMt> for ProductOrFileClassificationTaskStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileClassificationTaskStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileClassificationTaskStatusMt> for ProductOrFileClassificationTaskStatus {
	fn from(p: crate::v2_5::types::ProductOrFileClassificationTaskStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileClassificationTaskStatusMt> for ProductOrFileClassificationTaskStatus {
	fn into(self) -> crate::v2_5::types::ProductOrFileClassificationTaskStatusMt {
		self.0
	}
}


#[doc = r#"This message contains information necessary for static configuration of services that route data and streams. It is used to map source destinations to output destinations.  For example, this message can be used to configure an Multi-Level Security (MLS) guard, or a service that processes streams such as video.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileDisseminationConfiguration(
	pub crate::v2_5::types::ProductOrFileDisseminationConfigurationMt,
);
impl Deref for ProductOrFileDisseminationConfiguration {
	type Target = crate::v2_5::types::ProductOrFileDisseminationConfigurationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileDisseminationConfiguration {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileDisseminationConfigurationMt> for ProductOrFileDisseminationConfiguration {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileDisseminationConfigurationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileDisseminationConfigurationMt> for ProductOrFileDisseminationConfiguration {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileDisseminationConfigurationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileDisseminationConfigurationMt> for ProductOrFileDisseminationConfiguration {
	fn from(p: crate::v2_5::types::ProductOrFileDisseminationConfigurationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileDisseminationConfigurationMt> for ProductOrFileDisseminationConfiguration {
	fn into(self) -> crate::v2_5::types::ProductOrFileDisseminationConfigurationMt {
		self.0
	}
}


#[doc = r#"This message indicates a destination that products or files can be disseminated to and provides a user readable alias to that destination.  A destination does not imply that a product or file is actually being disseminated to the destination.  It is only used to describe the attributes of the dissemination destination.  Once created, it can be referenced by the Product Or File Dissemination Plan, Product Or File Dissemination Task, and Product Or File Dissemination Request.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileDisseminationDestination(
	pub crate::v2_5::types::ProductOrFileDisseminationDestinationMt,
);
impl Deref for ProductOrFileDisseminationDestination {
	type Target = crate::v2_5::types::ProductOrFileDisseminationDestinationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileDisseminationDestination {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileDisseminationDestinationMt> for ProductOrFileDisseminationDestination {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileDisseminationDestinationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileDisseminationDestinationMt> for ProductOrFileDisseminationDestination {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileDisseminationDestinationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileDisseminationDestinationMt> for ProductOrFileDisseminationDestination {
	fn from(p: crate::v2_5::types::ProductOrFileDisseminationDestinationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileDisseminationDestinationMt> for ProductOrFileDisseminationDestination {
	fn into(self) -> crate::v2_5::types::ProductOrFileDisseminationDestinationMt {
		self.0
	}
}


#[doc = r#"This message defines a system's default dissemination destinations of products or files by type.  It contains subplans which allow destinations to be established based on source, time, zones, and classification among other filter criteria.  Requests for the dissemination destination to archive and/or downgrade products are included.  ProductOrFileDisseminationPlans specify what default destinations to push products to in lieu of subscriptions, primarily for dissemination of products to non-UCI systems.

The Product Or File Dissemination Plan can be overridden by the operator utilizing the Product Or File Dissemination Task and/or Product Or File Dissemination Request by inclusion of a destination.  A Dissemination Request with destination omitted implies a dissemination to a destination determined by the Dissemination Plan.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileDisseminationPlan(
	pub crate::v2_5::types::ProductOrFileDisseminationPlanMt,
);
impl Deref for ProductOrFileDisseminationPlan {
	type Target = crate::v2_5::types::ProductOrFileDisseminationPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileDisseminationPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileDisseminationPlanMt> for ProductOrFileDisseminationPlan {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileDisseminationPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileDisseminationPlanMt> for ProductOrFileDisseminationPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileDisseminationPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileDisseminationPlanMt> for ProductOrFileDisseminationPlan {
	fn from(p: crate::v2_5::types::ProductOrFileDisseminationPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileDisseminationPlanMt> for ProductOrFileDisseminationPlan {
	fn into(self) -> crate::v2_5::types::ProductOrFileDisseminationPlanMt {
		self.0
	}
}


#[doc = r#"This message provides a report of the dissemination of a product or file.  It has 2 primary uses:
1.)  To report (via publish/broadcast) the state of product or file dissemination.  This is primarily for operator SA and is extremely useful for providing insight into dynamic dissemination destination changes of streaming products.  For example, a change in dissemination destination of an EOIR stream resulting from a Product Or File Dissemination Plan zone transition.

2.)  For persistence of state to support initialization and recovery of a service that is performing product or file dissemination.  This allows for a service to retrieve the dissemination destination of a product or file upon initialization.  This is primarily applicable to streaming products that are continuously streaming to a dissemination destination.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileDisseminationReport(
	pub crate::v2_5::types::ProductOrFileDisseminationReportMt,
);
impl Deref for ProductOrFileDisseminationReport {
	type Target = crate::v2_5::types::ProductOrFileDisseminationReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileDisseminationReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileDisseminationReportMt> for ProductOrFileDisseminationReport {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileDisseminationReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileDisseminationReportMt> for ProductOrFileDisseminationReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileDisseminationReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileDisseminationReportMt> for ProductOrFileDisseminationReport {
	fn from(p: crate::v2_5::types::ProductOrFileDisseminationReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileDisseminationReportMt> for ProductOrFileDisseminationReport {
	fn into(self) -> crate::v2_5::types::ProductOrFileDisseminationReportMt {
		self.0
	}
}


#[doc = r#"This message is a request that a product or file be disseminated to one or more destinations.
A Product Or File Dissemination Request directly invokes dissemination service functionality to disseminate a product or file.  Execution of the dissemination request would result in a Product Or File Dissemination Request Status followed by a Product Or File Dissemination Report.

There are 2 ways this message can be generated.  1.) By the operator to command immediate dissemination of a product or file.  2.) Automated by a service as a result of execution of a Dissemination Task.

When specifying a Dissemination Request, the user can choose to utilize the Product Or File Dissemination Plan to determine destination or can override the plan by specifying a destination.

If automatically generated as a result of Dissemination Task execution, the Dissemination requirements would be populated with those specified in the Dissemination Task.  This allows the default plan to be utilized or overridden on a task by task basis.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileDisseminationRequest(
	pub crate::v2_5::types::ProductOrFileDisseminationRequestMt,
);
impl Deref for ProductOrFileDisseminationRequest {
	type Target = crate::v2_5::types::ProductOrFileDisseminationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileDisseminationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileDisseminationRequestMt> for ProductOrFileDisseminationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileDisseminationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileDisseminationRequestMt> for ProductOrFileDisseminationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileDisseminationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileDisseminationRequestMt> for ProductOrFileDisseminationRequest {
	fn from(p: crate::v2_5::types::ProductOrFileDisseminationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileDisseminationRequestMt> for ProductOrFileDisseminationRequest {
	fn into(self) -> crate::v2_5::types::ProductOrFileDisseminationRequestMt {
		self.0
	}
}


#[doc = r#"This message provides status for a previously submitted ProductOrFileDisseminationRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileDisseminationRequestStatus(
	pub crate::v2_5::types::ProductOrFileDisseminationRequestStatusMt,
);
impl Deref for ProductOrFileDisseminationRequestStatus {
	type Target = crate::v2_5::types::ProductOrFileDisseminationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileDisseminationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileDisseminationRequestStatusMt> for ProductOrFileDisseminationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileDisseminationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileDisseminationRequestStatusMt> for ProductOrFileDisseminationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileDisseminationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileDisseminationRequestStatusMt> for ProductOrFileDisseminationRequestStatus {
	fn from(p: crate::v2_5::types::ProductOrFileDisseminationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileDisseminationRequestStatusMt> for ProductOrFileDisseminationRequestStatus {
	fn into(self) -> crate::v2_5::types::ProductOrFileDisseminationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is a task for a product or file to be disseminated to one or more destinations.
Dissemination Tasks do not directly invoke functionality.  They can be utilized to schedule post-collection, post-download, and post-processing dissemination of products.  As a result, it is expected that a Product Or File Dissemination Task would typically specify a download and/or processing task as a preceding dependent task.

Execution of a Dissemination Task would result in issue of a Dissemination Request to invoke dissemination service functionality.

When specifying a Dissemination Task, the user can choose to utilize the Product Or File Dissemination Plan to determine the dissemination destination or can override the plan by specifying a destination.  This allows the default plan to be overridden on a task by task basis.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileDisseminationTask(
	pub crate::v2_5::types::ProductOrFileDisseminationTaskMt,
);
impl Deref for ProductOrFileDisseminationTask {
	type Target = crate::v2_5::types::ProductOrFileDisseminationTaskMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileDisseminationTask {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileDisseminationTaskMt> for ProductOrFileDisseminationTask {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileDisseminationTaskMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileDisseminationTaskMt> for ProductOrFileDisseminationTask {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileDisseminationTaskMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileDisseminationTaskMt> for ProductOrFileDisseminationTask {
	fn from(p: crate::v2_5::types::ProductOrFileDisseminationTaskMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileDisseminationTaskMt> for ProductOrFileDisseminationTask {
	fn into(self) -> crate::v2_5::types::ProductOrFileDisseminationTaskMt {
		self.0
	}
}


#[doc = r#"This message provides the status of a Dissemination Task.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductOrFileDisseminationTaskStatus(
	pub crate::v2_5::types::ProductOrFileDisseminationTaskStatusMt,
);
impl Deref for ProductOrFileDisseminationTaskStatus {
	type Target = crate::v2_5::types::ProductOrFileDisseminationTaskStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductOrFileDisseminationTaskStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductOrFileDisseminationTaskStatusMt> for ProductOrFileDisseminationTaskStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ProductOrFileDisseminationTaskStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductOrFileDisseminationTaskStatusMt> for ProductOrFileDisseminationTaskStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductOrFileDisseminationTaskStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductOrFileDisseminationTaskStatusMt> for ProductOrFileDisseminationTaskStatus {
	fn from(p: crate::v2_5::types::ProductOrFileDisseminationTaskStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductOrFileDisseminationTaskStatusMt> for ProductOrFileDisseminationTaskStatus {
	fn into(self) -> crate::v2_5::types::ProductOrFileDisseminationTaskStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to advertise the ability to process products. It specifies what type of inputs can be processed, limitations on the type of processing, and the available output products.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductProcessingFunction(
	pub crate::v2_5::types::ProductProcessingFunctionMt,
);
impl Deref for ProductProcessingFunction {
	type Target = crate::v2_5::types::ProductProcessingFunctionMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductProcessingFunction {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductProcessingFunctionMt> for ProductProcessingFunction {
	fn as_ref(&self) -> &crate::v2_5::types::ProductProcessingFunctionMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductProcessingFunctionMt> for ProductProcessingFunction {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductProcessingFunctionMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductProcessingFunctionMt> for ProductProcessingFunction {
	fn from(p: crate::v2_5::types::ProductProcessingFunctionMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductProcessingFunctionMt> for ProductProcessingFunction {
	fn into(self) -> crate::v2_5::types::ProductProcessingFunctionMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the product processing functions available to the system.   This includes information regarding whether or not each function is currently available.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductProcessingFunctionStatus(
	pub crate::v2_5::types::ProductProcessingFunctionStatusMt,
);
impl Deref for ProductProcessingFunctionStatus {
	type Target = crate::v2_5::types::ProductProcessingFunctionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductProcessingFunctionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductProcessingFunctionStatusMt> for ProductProcessingFunctionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ProductProcessingFunctionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductProcessingFunctionStatusMt> for ProductProcessingFunctionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductProcessingFunctionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductProcessingFunctionStatusMt> for ProductProcessingFunctionStatus {
	fn from(p: crate::v2_5::types::ProductProcessingFunctionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductProcessingFunctionStatusMt> for ProductProcessingFunctionStatus {
	fn into(self) -> crate::v2_5::types::ProductProcessingFunctionStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the default system rules for determining the type of post-collect processing and processing parameters to apply to specific product types.
Default processing types and parameters can be overridden using the Processing Task and Processing Request messages.  A Processing Request with processing type and parameter omitted implies process via the Product processing Plan.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductProcessingPlan(
	pub crate::v2_5::types::ProductProcessingPlanMt,
);
impl Deref for ProductProcessingPlan {
	type Target = crate::v2_5::types::ProductProcessingPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductProcessingPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductProcessingPlanMt> for ProductProcessingPlan {
	fn as_ref(&self) -> &crate::v2_5::types::ProductProcessingPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductProcessingPlanMt> for ProductProcessingPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductProcessingPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductProcessingPlanMt> for ProductProcessingPlan {
	fn from(p: crate::v2_5::types::ProductProcessingPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductProcessingPlanMt> for ProductProcessingPlan {
	fn into(self) -> crate::v2_5::types::ProductProcessingPlanMt {
		self.0
	}
}


#[doc = r#"This message provides a report of the processing of a product.  It has 2 primary uses:
1.)  To report (via publish/broadcast) the state of product processing.  This is primarily for operator SA and is extremely useful for providing insight into dynamic processing type and parameter changes of streaming products.  For example, a change in processing of an EOIR stream resulting from a Product Processing Plan zone transition.

2.)  For persistence of state to support initialization and recovery of a service that is performing product processing.  This allows for a service to retrieve the processing type and parameters of a product upon initialization.  This is primarily applicable to streaming products that are continuously streaming and the processing type is continuously applied.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductProcessingReport(
	pub crate::v2_5::types::ProductProcessingReportMt,
);
impl Deref for ProductProcessingReport {
	type Target = crate::v2_5::types::ProductProcessingReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductProcessingReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductProcessingReportMt> for ProductProcessingReport {
	fn as_ref(&self) -> &crate::v2_5::types::ProductProcessingReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductProcessingReportMt> for ProductProcessingReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductProcessingReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductProcessingReportMt> for ProductProcessingReport {
	fn from(p: crate::v2_5::types::ProductProcessingReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductProcessingReportMt> for ProductProcessingReport {
	fn into(self) -> crate::v2_5::types::ProductProcessingReportMt {
		self.0
	}
}


#[doc = r#"This message represents a request that a new product be created by processing existing products or products that will be collected.
A Product Processing Request directly invokes processing service functionality to process a product.  Execution of the processing request would result in a Product Processing Request Status followed by a Product Processing Report.

There are 2 ways this message can be generated.  1.) By the operator to command immediate processing of a product.  2.) Automated by a service as a result of execution of a Processing Task.

When specifying a Processing Request, the user can choose to utilize the Product Processing Plan to determine processing type and parameters or can override the plan by specifying processing type and parameters.

If automatically generated as a result of Processing Task execution, the processing requirements would be populated with those specified in the Processing Task.  This allows the default plan to be utilized or overridden on a task by task basis.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductProcessingRequest(
	pub crate::v2_5::types::ProductProcessingRequestMt,
);
impl Deref for ProductProcessingRequest {
	type Target = crate::v2_5::types::ProductProcessingRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductProcessingRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductProcessingRequestMt> for ProductProcessingRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ProductProcessingRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductProcessingRequestMt> for ProductProcessingRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductProcessingRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductProcessingRequestMt> for ProductProcessingRequest {
	fn from(p: crate::v2_5::types::ProductProcessingRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductProcessingRequestMt> for ProductProcessingRequest {
	fn into(self) -> crate::v2_5::types::ProductProcessingRequestMt {
		self.0
	}
}


#[doc = r#"This message provides status for a previously submitted ProductProcessingRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductProcessingRequestStatus(
	pub crate::v2_5::types::ProductProcessingRequestStatusMt,
);
impl Deref for ProductProcessingRequestStatus {
	type Target = crate::v2_5::types::ProductProcessingRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductProcessingRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductProcessingRequestStatusMt> for ProductProcessingRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ProductProcessingRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductProcessingRequestStatusMt> for ProductProcessingRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductProcessingRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductProcessingRequestStatusMt> for ProductProcessingRequestStatus {
	fn from(p: crate::v2_5::types::ProductProcessingRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductProcessingRequestStatusMt> for ProductProcessingRequestStatus {
	fn into(self) -> crate::v2_5::types::ProductProcessingRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is a task that a new product be created by processing existing products or products that will be created in the future.
Processing Tasks do not directly invoke functionality.  They are utilized to schedule post-collection and post-download processing of products.  As a result, it is expected that a Product Processing Task would typically specify a download and/or collection task as a preceding dependent task.

Execution of a Processing Task would result in issue of a Processing Request to invoke processing service functionality.

When specifying a Processing Task, the user can choose to utilize the Product Processing Plan to determine processing type or can override the plan by specifying processing type.  This allows the default plan to be overridden on a task by task basis.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductProcessingTask(
	pub crate::v2_5::types::ProductProcessingTaskMt,
);
impl Deref for ProductProcessingTask {
	type Target = crate::v2_5::types::ProductProcessingTaskMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductProcessingTask {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductProcessingTaskMt> for ProductProcessingTask {
	fn as_ref(&self) -> &crate::v2_5::types::ProductProcessingTaskMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductProcessingTaskMt> for ProductProcessingTask {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductProcessingTaskMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductProcessingTaskMt> for ProductProcessingTask {
	fn from(p: crate::v2_5::types::ProductProcessingTaskMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductProcessingTaskMt> for ProductProcessingTask {
	fn into(self) -> crate::v2_5::types::ProductProcessingTaskMt {
		self.0
	}
}


#[doc = r#"This message provides status for a task that a new product be created by processing existing products or products that will be collected.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ProductProcessingTaskStatus(
	pub crate::v2_5::types::ProductProcessingTaskStatusMt,
);
impl Deref for ProductProcessingTaskStatus {
	type Target = crate::v2_5::types::ProductProcessingTaskStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ProductProcessingTaskStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ProductProcessingTaskStatusMt> for ProductProcessingTaskStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ProductProcessingTaskStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ProductProcessingTaskStatusMt> for ProductProcessingTaskStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ProductProcessingTaskStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ProductProcessingTaskStatusMt> for ProductProcessingTaskStatus {
	fn from(p: crate::v2_5::types::ProductProcessingTaskStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ProductProcessingTaskStatusMt> for ProductProcessingTaskStatus {
	fn into(self) -> crate::v2_5::types::ProductProcessingTaskStatusMt {
		self.0
	}
}


#[doc = r#"This message provides the set of propagator settings to be used when propagating a resident space object (RSO). A propagator consists of a force model and a numerical integration model. Models can be customized to meet the needs of the mission.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PropagatorSettings(
	pub crate::v2_5::types::PropagatorSettingsMt,
);
impl Deref for PropagatorSettings {
	type Target = crate::v2_5::types::PropagatorSettingsMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PropagatorSettings {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PropagatorSettingsMt> for PropagatorSettings {
	fn as_ref(&self) -> &crate::v2_5::types::PropagatorSettingsMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PropagatorSettingsMt> for PropagatorSettings {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PropagatorSettingsMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PropagatorSettingsMt> for PropagatorSettings {
	fn from(p: crate::v2_5::types::PropagatorSettingsMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PropagatorSettingsMt> for PropagatorSettings {
	fn into(self) -> crate::v2_5::types::PropagatorSettingsMt {
		self.0
	}
}


#[doc = r#"This message indicates a request of the set of propagator settings to be used when propagating a resident space object (RSO).UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PropagatorSettingsDataRequest(
	pub crate::v2_5::types::PropagatorSettingsDataRequestMt,
);
impl Deref for PropagatorSettingsDataRequest {
	type Target = crate::v2_5::types::PropagatorSettingsDataRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PropagatorSettingsDataRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PropagatorSettingsDataRequestMt> for PropagatorSettingsDataRequest {
	fn as_ref(&self) -> &crate::v2_5::types::PropagatorSettingsDataRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PropagatorSettingsDataRequestMt> for PropagatorSettingsDataRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PropagatorSettingsDataRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PropagatorSettingsDataRequestMt> for PropagatorSettingsDataRequest {
	fn from(p: crate::v2_5::types::PropagatorSettingsDataRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PropagatorSettingsDataRequestMt> for PropagatorSettingsDataRequest {
	fn into(self) -> crate::v2_5::types::PropagatorSettingsDataRequestMt {
		self.0
	}
}


#[doc = r#"This message is generated in response to a PropagatorSettingsDataRequest. It provides the state of the request and allows services to return details of the force model and a numerical integration model.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PropagatorSettingsDataRequestStatus(
	pub crate::v2_5::types::PropagatorSettingsDataRequestStatusMt,
);
impl Deref for PropagatorSettingsDataRequestStatus {
	type Target = crate::v2_5::types::PropagatorSettingsDataRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PropagatorSettingsDataRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PropagatorSettingsDataRequestStatusMt> for PropagatorSettingsDataRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::PropagatorSettingsDataRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PropagatorSettingsDataRequestStatusMt> for PropagatorSettingsDataRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PropagatorSettingsDataRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PropagatorSettingsDataRequestStatusMt> for PropagatorSettingsDataRequestStatus {
	fn from(p: crate::v2_5::types::PropagatorSettingsDataRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PropagatorSettingsDataRequestStatusMt> for PropagatorSettingsDataRequestStatus {
	fn into(self) -> crate::v2_5::types::PropagatorSettingsDataRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message represents a signals intelligence pulse stream.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct PulseData(
	pub crate::v2_5::types::PulseDataMt,
);
impl Deref for PulseData {
	type Target = crate::v2_5::types::PulseDataMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for PulseData {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::PulseDataMt> for PulseData {
	fn as_ref(&self) -> &crate::v2_5::types::PulseDataMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::PulseDataMt> for PulseData {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::PulseDataMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::PulseDataMt> for PulseData {
	fn from(p: crate::v2_5::types::PulseDataMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::PulseDataMt> for PulseData {
	fn into(self) -> crate::v2_5::types::PulseDataMt {
		self.0
	}
}


#[doc = r#"This message represents a query for a new message and/or a filtered set of message or messages.  It is intended to support **service/application-level** queries for messages; it is not intended to replace message retry, persistence, etc. capabilities in the middleware and/or transport level or be used in lieu of the ResendDataRequest message.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct QueryDataRequest(
	pub crate::v2_5::types::QueryDataRequestMt,
);
impl Deref for QueryDataRequest {
	type Target = crate::v2_5::types::QueryDataRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for QueryDataRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::QueryDataRequestMt> for QueryDataRequest {
	fn as_ref(&self) -> &crate::v2_5::types::QueryDataRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::QueryDataRequestMt> for QueryDataRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::QueryDataRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::QueryDataRequestMt> for QueryDataRequest {
	fn from(p: crate::v2_5::types::QueryDataRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::QueryDataRequestMt> for QueryDataRequest {
	fn into(self) -> crate::v2_5::types::QueryDataRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the results of a QueryDataRequest.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct QueryDataRequestStatus(
	pub crate::v2_5::types::QueryDataRequestStatusMt,
);
impl Deref for QueryDataRequestStatus {
	type Target = crate::v2_5::types::QueryDataRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for QueryDataRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::QueryDataRequestStatusMt> for QueryDataRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::QueryDataRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::QueryDataRequestStatusMt> for QueryDataRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::QueryDataRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::QueryDataRequestStatusMt> for QueryDataRequestStatus {
	fn from(p: crate::v2_5::types::QueryDataRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::QueryDataRequestStatusMt> for QueryDataRequestStatus {
	fn into(self) -> crate::v2_5::types::QueryDataRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the RadarAltimeter Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (RadarAltimeterCommand) from an Operator or Capability management Service, 3) currently in-work RadarAltimeter, 4) RadarAltimeter scheduled for the future and 5) RadarAltimeter that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single RadarAltimeterCommand or other triggering event can result in multiple activities within the RadarAltimeterActivity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RadarAltimeterActivity(
	pub crate::v2_5::types::RadarAltimeterActivityMt,
);
impl Deref for RadarAltimeterActivity {
	type Target = crate::v2_5::types::RadarAltimeterActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RadarAltimeterActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RadarAltimeterActivityMt> for RadarAltimeterActivity {
	fn as_ref(&self) -> &crate::v2_5::types::RadarAltimeterActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RadarAltimeterActivityMt> for RadarAltimeterActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RadarAltimeterActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RadarAltimeterActivityMt> for RadarAltimeterActivity {
	fn from(p: crate::v2_5::types::RadarAltimeterActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RadarAltimeterActivityMt> for RadarAltimeterActivity {
	fn into(self) -> crate::v2_5::types::RadarAltimeterActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the RadarAltimeter category of UCI Capability.  The RadarAltimeter measures platform height above terrain and vertical closing velocity through active radar detection.  This message "advertises" the mostly static characteristics of a mission-ready RadarAltimeter Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RadarAltimeterCapability(
	pub crate::v2_5::types::RadarAltimeterCapabilityMt,
);
impl Deref for RadarAltimeterCapability {
	type Target = crate::v2_5::types::RadarAltimeterCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RadarAltimeterCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RadarAltimeterCapabilityMt> for RadarAltimeterCapability {
	fn as_ref(&self) -> &crate::v2_5::types::RadarAltimeterCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RadarAltimeterCapabilityMt> for RadarAltimeterCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RadarAltimeterCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RadarAltimeterCapabilityMt> for RadarAltimeterCapability {
	fn from(p: crate::v2_5::types::RadarAltimeterCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RadarAltimeterCapabilityMt> for RadarAltimeterCapability {
	fn into(self) -> crate::v2_5::types::RadarAltimeterCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the RadarAltimeter capabilities.   This includes whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RadarAltimeterCapabilityStatus(
	pub crate::v2_5::types::RadarAltimeterCapabilityStatusMt,
);
impl Deref for RadarAltimeterCapabilityStatus {
	type Target = crate::v2_5::types::RadarAltimeterCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RadarAltimeterCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RadarAltimeterCapabilityStatusMt> for RadarAltimeterCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RadarAltimeterCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RadarAltimeterCapabilityStatusMt> for RadarAltimeterCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RadarAltimeterCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RadarAltimeterCapabilityStatusMt> for RadarAltimeterCapabilityStatus {
	fn from(p: crate::v2_5::types::RadarAltimeterCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RadarAltimeterCapabilityStatusMt> for RadarAltimeterCapabilityStatus {
	fn into(self) -> crate::v2_5::types::RadarAltimeterCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the RadarAltimeter form of the general UCI Capability Command. It is used to manually invoke a RadarAltimeter Capability to perform a new RadarAltimeter Activity or change an existing interactive RadarAltimeter Activity. It is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan. Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages. Several mechanisms are provided in other messages to tailor the relationship and relative importance of RadarAltimeterCommands including Capability precedence, RadarAltimeterCommand rank, and RadarAltimeterActivity rank.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RadarAltimeterCommand(
	pub crate::v2_5::types::RadarAltimeterCommandMt,
);
impl Deref for RadarAltimeterCommand {
	type Target = crate::v2_5::types::RadarAltimeterCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RadarAltimeterCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RadarAltimeterCommandMt> for RadarAltimeterCommand {
	fn as_ref(&self) -> &crate::v2_5::types::RadarAltimeterCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RadarAltimeterCommandMt> for RadarAltimeterCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RadarAltimeterCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RadarAltimeterCommandMt> for RadarAltimeterCommand {
	fn from(p: crate::v2_5::types::RadarAltimeterCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RadarAltimeterCommandMt> for RadarAltimeterCommand {
	fn into(self) -> crate::v2_5::types::RadarAltimeterCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an RadarAltimeterCommand.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity(ies) that result from the command will report status via the RadarAltimeterActivity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RadarAltimeterCommandStatus(
	pub crate::v2_5::types::RadarAltimeterCommandStatusMt,
);
impl Deref for RadarAltimeterCommandStatus {
	type Target = crate::v2_5::types::RadarAltimeterCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RadarAltimeterCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RadarAltimeterCommandStatusMt> for RadarAltimeterCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RadarAltimeterCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RadarAltimeterCommandStatusMt> for RadarAltimeterCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RadarAltimeterCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RadarAltimeterCommandStatusMt> for RadarAltimeterCommandStatus {
	fn from(p: crate::v2_5::types::RadarAltimeterCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RadarAltimeterCommandStatusMt> for RadarAltimeterCommandStatus {
	fn into(self) -> crate::v2_5::types::RadarAltimeterCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message represents a RadarAltimeter report from a System.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RadarAltimeterReport(
	pub crate::v2_5::types::RadarAltimeterReportMt,
);
impl Deref for RadarAltimeterReport {
	type Target = crate::v2_5::types::RadarAltimeterReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RadarAltimeterReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RadarAltimeterReportMt> for RadarAltimeterReport {
	fn as_ref(&self) -> &crate::v2_5::types::RadarAltimeterReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RadarAltimeterReportMt> for RadarAltimeterReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RadarAltimeterReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RadarAltimeterReportMt> for RadarAltimeterReport {
	fn from(p: crate::v2_5::types::RadarAltimeterReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RadarAltimeterReportMt> for RadarAltimeterReport {
	fn into(self) -> crate::v2_5::types::RadarAltimeterReportMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the RadarAltimeter Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered pre-settings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RadarAltimeterSettingsCommand(
	pub crate::v2_5::types::RadarAltimeterSettingsCommandMt,
);
impl Deref for RadarAltimeterSettingsCommand {
	type Target = crate::v2_5::types::RadarAltimeterSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RadarAltimeterSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RadarAltimeterSettingsCommandMt> for RadarAltimeterSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::RadarAltimeterSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RadarAltimeterSettingsCommandMt> for RadarAltimeterSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RadarAltimeterSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RadarAltimeterSettingsCommandMt> for RadarAltimeterSettingsCommand {
	fn from(p: crate::v2_5::types::RadarAltimeterSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RadarAltimeterSettingsCommandMt> for RadarAltimeterSettingsCommand {
	fn into(self) -> crate::v2_5::types::RadarAltimeterSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message reports the acknowledgement and/or acceptance of an RadarAltimeter settings command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RadarAltimeterSettingsCommandStatus(
	pub crate::v2_5::types::RadarAltimeterSettingsCommandStatusMt,
);
impl Deref for RadarAltimeterSettingsCommandStatus {
	type Target = crate::v2_5::types::RadarAltimeterSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RadarAltimeterSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RadarAltimeterSettingsCommandStatusMt> for RadarAltimeterSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RadarAltimeterSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RadarAltimeterSettingsCommandStatusMt> for RadarAltimeterSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RadarAltimeterSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RadarAltimeterSettingsCommandStatusMt> for RadarAltimeterSettingsCommandStatus {
	fn from(p: crate::v2_5::types::RadarAltimeterSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RadarAltimeterSettingsCommandStatusMt> for RadarAltimeterSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::RadarAltimeterSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message instructs the recipient (subscriber) that an RDMA is ready to be established.  The subscriber should use the information in this message to complete an RDMA connection using the libfabrics API/library.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RdmaInitialize(
	pub crate::v2_5::types::RdmaInitializeMt,
);
impl Deref for RdmaInitialize {
	type Target = crate::v2_5::types::RdmaInitializeMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RdmaInitialize {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RdmaInitializeMt> for RdmaInitialize {
	fn as_ref(&self) -> &crate::v2_5::types::RdmaInitializeMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RdmaInitializeMt> for RdmaInitialize {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RdmaInitializeMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RdmaInitializeMt> for RdmaInitialize {
	fn from(p: crate::v2_5::types::RdmaInitializeMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RdmaInitializeMt> for RdmaInitialize {
	fn into(self) -> crate::v2_5::types::RdmaInitializeMt {
		self.0
	}
}


#[doc = r#"This message requests the server open an RDMA connection using the supplied information.  The server should respond with an RDMA_Initialize message to confirm RDMA connection details and signal the RDMA connection is ready for connection after initializing the connection using the libfabrics API/library.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RdmaInitializeSetup(
	pub crate::v2_5::types::RdmaInitializeSetupMt,
);
impl Deref for RdmaInitializeSetup {
	type Target = crate::v2_5::types::RdmaInitializeSetupMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RdmaInitializeSetup {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RdmaInitializeSetupMt> for RdmaInitializeSetup {
	fn as_ref(&self) -> &crate::v2_5::types::RdmaInitializeSetupMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RdmaInitializeSetupMt> for RdmaInitializeSetup {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RdmaInitializeSetupMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RdmaInitializeSetupMt> for RdmaInitializeSetup {
	fn from(p: crate::v2_5::types::RdmaInitializeSetupMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RdmaInitializeSetupMt> for RdmaInitializeSetup {
	fn into(self) -> crate::v2_5::types::RdmaInitializeSetupMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the Reference Capability of a System.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ReferenceActivity(
	pub crate::v2_5::types::ReferenceActivityMt,
);
impl Deref for ReferenceActivity {
	type Target = crate::v2_5::types::ReferenceActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ReferenceActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ReferenceActivityMt> for ReferenceActivity {
	fn as_ref(&self) -> &crate::v2_5::types::ReferenceActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ReferenceActivityMt> for ReferenceActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ReferenceActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ReferenceActivityMt> for ReferenceActivity {
	fn from(p: crate::v2_5::types::ReferenceActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ReferenceActivityMt> for ReferenceActivity {
	fn into(self) -> crate::v2_5::types::ReferenceActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the Reference category of UCI Capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ReferenceCapability(
	pub crate::v2_5::types::ReferenceCapabilityMt,
);
impl Deref for ReferenceCapability {
	type Target = crate::v2_5::types::ReferenceCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ReferenceCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ReferenceCapabilityMt> for ReferenceCapability {
	fn as_ref(&self) -> &crate::v2_5::types::ReferenceCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ReferenceCapabilityMt> for ReferenceCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ReferenceCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ReferenceCapabilityMt> for ReferenceCapability {
	fn from(p: crate::v2_5::types::ReferenceCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ReferenceCapabilityMt> for ReferenceCapability {
	fn into(self) -> crate::v2_5::types::ReferenceCapabilityMt {
		self.0
	}
}


#[doc = r#"This message contains the current status of the reference capabilities available to the system.  A ReferenceCapability is not available to task or command.  Some of the common child elements are likely never applicable to a ReferenceCapability.  Since they're optional they don't explicitly interfere with primary use cases for ReferenceCapability.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ReferenceCapabilityStatus(
	pub crate::v2_5::types::ReferenceCapabilityStatusMt,
);
impl Deref for ReferenceCapabilityStatus {
	type Target = crate::v2_5::types::ReferenceCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ReferenceCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ReferenceCapabilityStatusMt> for ReferenceCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ReferenceCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ReferenceCapabilityStatusMt> for ReferenceCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ReferenceCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ReferenceCapabilityStatusMt> for ReferenceCapabilityStatus {
	fn from(p: crate::v2_5::types::ReferenceCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ReferenceCapabilityStatusMt> for ReferenceCapabilityStatus {
	fn into(self) -> crate::v2_5::types::ReferenceCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to send reference frame settings position, attitude, and velocity.  This message could be used to publish reference frame settings to the air vehicle to support relative navigation.  It can also be used to provide a reference frame for OpPoints, OpLines or OpZones that are relative to a moving object.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ReferenceFrame(
	pub crate::v2_5::types::ReferenceFrameMt,
);
impl Deref for ReferenceFrame {
	type Target = crate::v2_5::types::ReferenceFrameMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ReferenceFrame {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ReferenceFrameMt> for ReferenceFrame {
	fn as_ref(&self) -> &crate::v2_5::types::ReferenceFrameMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ReferenceFrameMt> for ReferenceFrame {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ReferenceFrameMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ReferenceFrameMt> for ReferenceFrame {
	fn from(p: crate::v2_5::types::ReferenceFrameMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ReferenceFrameMt> for ReferenceFrame {
	fn into(self) -> crate::v2_5::types::ReferenceFrameMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the Refuel Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (TankingCommand) from an Operator or Capability management Service, 3) currently in-work Tanking, 4) Tanking scheduled for the future and 5) Tanking that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single TankingCommand or other triggering event can result in multiple activities within the TankingActivity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RefuelActivity(
	pub crate::v2_5::types::RefuelActivityMt,
);
impl Deref for RefuelActivity {
	type Target = crate::v2_5::types::RefuelActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RefuelActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RefuelActivityMt> for RefuelActivity {
	fn as_ref(&self) -> &crate::v2_5::types::RefuelActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RefuelActivityMt> for RefuelActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RefuelActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RefuelActivityMt> for RefuelActivity {
	fn from(p: crate::v2_5::types::RefuelActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RefuelActivityMt> for RefuelActivity {
	fn into(self) -> crate::v2_5::types::RefuelActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the Refueling category of UCI Capability.  Refueling refers to Aerial Refueling where a tanker gives gas to a receiver.  This message "advertises" the mostly static characteristics of a mission-ready Tanking Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RefuelCapability(
	pub crate::v2_5::types::RefuelCapabilityMt,
);
impl Deref for RefuelCapability {
	type Target = crate::v2_5::types::RefuelCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RefuelCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RefuelCapabilityMt> for RefuelCapability {
	fn as_ref(&self) -> &crate::v2_5::types::RefuelCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RefuelCapabilityMt> for RefuelCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RefuelCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RefuelCapabilityMt> for RefuelCapability {
	fn from(p: crate::v2_5::types::RefuelCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RefuelCapabilityMt> for RefuelCapability {
	fn into(self) -> crate::v2_5::types::RefuelCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the tanking capabilities.   This includes whether or not each capability is currently available based on hardware status, commanded operational states,  etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RefuelCapabilityStatus(
	pub crate::v2_5::types::RefuelCapabilityStatusMt,
);
impl Deref for RefuelCapabilityStatus {
	type Target = crate::v2_5::types::RefuelCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RefuelCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RefuelCapabilityStatusMt> for RefuelCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RefuelCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RefuelCapabilityStatusMt> for RefuelCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RefuelCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RefuelCapabilityStatusMt> for RefuelCapabilityStatus {
	fn from(p: crate::v2_5::types::RefuelCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RefuelCapabilityStatusMt> for RefuelCapabilityStatus {
	fn into(self) -> crate::v2_5::types::RefuelCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the Refueling form of the general UCI Capability Command.  It is used to manually invoke a Refuel Capability to perform a new Refuel Activity or change an existing interactive Refuel Activity.  It differs from a Refuel Task because it is intended for direct interaction with the host of the Capability, not a planning Service, and therefore is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan.  Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages.  Capability Commands can be used in parallel with Tasks, but are generally deferential to them.  However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RefuelCommand(
	pub crate::v2_5::types::RefuelCommandMt,
);
impl Deref for RefuelCommand {
	type Target = crate::v2_5::types::RefuelCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RefuelCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RefuelCommandMt> for RefuelCommand {
	fn as_ref(&self) -> &crate::v2_5::types::RefuelCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RefuelCommandMt> for RefuelCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RefuelCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RefuelCommandMt> for RefuelCommand {
	fn from(p: crate::v2_5::types::RefuelCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RefuelCommandMt> for RefuelCommand {
	fn into(self) -> crate::v2_5::types::RefuelCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of a RefuelCommand.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can started or scheduled.  The details of the specific activity or activities that result from the command will be statused via the RefuelActivity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RefuelCommandStatus(
	pub crate::v2_5::types::RefuelCommandStatusMt,
);
impl Deref for RefuelCommandStatus {
	type Target = crate::v2_5::types::RefuelCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RefuelCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RefuelCommandStatusMt> for RefuelCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RefuelCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RefuelCommandStatusMt> for RefuelCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RefuelCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RefuelCommandStatusMt> for RefuelCommandStatus {
	fn from(p: crate::v2_5::types::RefuelCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RefuelCommandStatusMt> for RefuelCommandStatus {
	fn into(self) -> crate::v2_5::types::RefuelCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the Refuel Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RefuelSettingsCommand(
	pub crate::v2_5::types::RefuelSettingsCommandMt,
);
impl Deref for RefuelSettingsCommand {
	type Target = crate::v2_5::types::RefuelSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RefuelSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RefuelSettingsCommandMt> for RefuelSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::RefuelSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RefuelSettingsCommandMt> for RefuelSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RefuelSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RefuelSettingsCommandMt> for RefuelSettingsCommand {
	fn from(p: crate::v2_5::types::RefuelSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RefuelSettingsCommandMt> for RefuelSettingsCommand {
	fn into(self) -> crate::v2_5::types::RefuelSettingsCommandMt {
		self.0
	}
}


#[doc = r#"Reports the acknowledgment and/or acceptance of a Refuel Settings Command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RefuelSettingsCommandStatus(
	pub crate::v2_5::types::RefuelSettingsCommandStatusMt,
);
impl Deref for RefuelSettingsCommandStatus {
	type Target = crate::v2_5::types::RefuelSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RefuelSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RefuelSettingsCommandStatusMt> for RefuelSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RefuelSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RefuelSettingsCommandStatusMt> for RefuelSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RefuelSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RefuelSettingsCommandStatusMt> for RefuelSettingsCommandStatus {
	fn from(p: crate::v2_5::types::RefuelSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RefuelSettingsCommandStatusMt> for RefuelSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::RefuelSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message to represent one of the various types of relationships that occur in the course of system operations - Pairings (Associations or Couplings), Engagements, and Threat Warnings.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RelationshipDesignation(
	pub crate::v2_5::types::RelationshipDesignationMt,
);
impl Deref for RelationshipDesignation {
	type Target = crate::v2_5::types::RelationshipDesignationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RelationshipDesignation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RelationshipDesignationMt> for RelationshipDesignation {
	fn as_ref(&self) -> &crate::v2_5::types::RelationshipDesignationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RelationshipDesignationMt> for RelationshipDesignation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RelationshipDesignationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RelationshipDesignationMt> for RelationshipDesignation {
	fn from(p: crate::v2_5::types::RelationshipDesignationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RelationshipDesignationMt> for RelationshipDesignation {
	fn into(self) -> crate::v2_5::types::RelationshipDesignationMt {
		self.0
	}
}


#[doc = r#"This message provides metrics for [Requirement]Plan, generally metrics related to allocation of Requirements to Systems.  This message is intended for use prior to execution of a plan; for actual results of the plan, systems should use those status and activity messages produced during execution to derive metrics.
The intent of the *Plan Metrics messages are to provide calculated metrics that are based on existing plan input data. This is to continue the current paradigm of how metrics were represented in existing/previous MissionPlan and other sub plans. There is a distinction between the *Plan Metrics and the Assessment message, in that Assessment gives much more specific data and can consider other supporting systems and their capabilities in the assessment.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RequirementMetrics(
	pub crate::v2_5::types::RequirementMetricsMt,
);
impl Deref for RequirementMetrics {
	type Target = crate::v2_5::types::RequirementMetricsMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RequirementMetrics {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RequirementMetricsMt> for RequirementMetrics {
	fn as_ref(&self) -> &crate::v2_5::types::RequirementMetricsMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RequirementMetricsMt> for RequirementMetrics {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RequirementMetricsMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RequirementMetricsMt> for RequirementMetrics {
	fn from(p: crate::v2_5::types::RequirementMetricsMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RequirementMetricsMt> for RequirementMetrics {
	fn into(self) -> crate::v2_5::types::RequirementMetricsMt {
		self.0
	}
}


#[doc = r#"This message requests the generation of metrics for [Requirement]Plan.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RequirementMetricsRequest(
	pub crate::v2_5::types::RequirementMetricsRequestMt,
);
impl Deref for RequirementMetricsRequest {
	type Target = crate::v2_5::types::RequirementMetricsRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RequirementMetricsRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RequirementMetricsRequestMt> for RequirementMetricsRequest {
	fn as_ref(&self) -> &crate::v2_5::types::RequirementMetricsRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RequirementMetricsRequestMt> for RequirementMetricsRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RequirementMetricsRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RequirementMetricsRequestMt> for RequirementMetricsRequest {
	fn from(p: crate::v2_5::types::RequirementMetricsRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RequirementMetricsRequestMt> for RequirementMetricsRequest {
	fn into(self) -> crate::v2_5::types::RequirementMetricsRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status of a RequirementMetricsRequest.  In the event that metric reporting was incomplete, this message should provide details on why the process was unsuccessful.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RequirementMetricsRequestStatus(
	pub crate::v2_5::types::RequirementMetricsRequestStatusMt,
);
impl Deref for RequirementMetricsRequestStatus {
	type Target = crate::v2_5::types::RequirementMetricsRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RequirementMetricsRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RequirementMetricsRequestStatusMt> for RequirementMetricsRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RequirementMetricsRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RequirementMetricsRequestStatusMt> for RequirementMetricsRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RequirementMetricsRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RequirementMetricsRequestStatusMt> for RequirementMetricsRequestStatus {
	fn from(p: crate::v2_5::types::RequirementMetricsRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RequirementMetricsRequestStatusMt> for RequirementMetricsRequestStatus {
	fn into(self) -> crate::v2_5::types::RequirementMetricsRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies options for allocation of Requirements to Systems.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RequirementOptions(
	pub crate::v2_5::types::RequirementOptionsMt,
);
impl Deref for RequirementOptions {
	type Target = crate::v2_5::types::RequirementOptionsMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RequirementOptions {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RequirementOptionsMt> for RequirementOptions {
	fn as_ref(&self) -> &crate::v2_5::types::RequirementOptionsMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RequirementOptionsMt> for RequirementOptions {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RequirementOptionsMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RequirementOptionsMt> for RequirementOptions {
	fn from(p: crate::v2_5::types::RequirementOptionsMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RequirementOptionsMt> for RequirementOptions {
	fn into(self) -> crate::v2_5::types::RequirementOptionsMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to develop/analyze options for allocating Requirements to Systems.  The results are given in the RequirementOptions message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RequirementOptionsCommand(
	pub crate::v2_5::types::RequirementOptionsCommandMt,
);
impl Deref for RequirementOptionsCommand {
	type Target = crate::v2_5::types::RequirementOptionsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RequirementOptionsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RequirementOptionsCommandMt> for RequirementOptionsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::RequirementOptionsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RequirementOptionsCommandMt> for RequirementOptionsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RequirementOptionsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RequirementOptionsCommandMt> for RequirementOptionsCommand {
	fn from(p: crate::v2_5::types::RequirementOptionsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RequirementOptionsCommandMt> for RequirementOptionsCommand {
	fn into(self) -> crate::v2_5::types::RequirementOptionsCommandMt {
		self.0
	}
}


#[doc = r#"This message is a response to the RequirementOptionsCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RequirementOptionsCommandStatus(
	pub crate::v2_5::types::RequirementOptionsCommandStatusMt,
);
impl Deref for RequirementOptionsCommandStatus {
	type Target = crate::v2_5::types::RequirementOptionsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RequirementOptionsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RequirementOptionsCommandStatusMt> for RequirementOptionsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RequirementOptionsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RequirementOptionsCommandStatusMt> for RequirementOptionsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RequirementOptionsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RequirementOptionsCommandStatusMt> for RequirementOptionsCommandStatus {
	fn from(p: crate::v2_5::types::RequirementOptionsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RequirementOptionsCommandStatusMt> for RequirementOptionsCommandStatus {
	fn into(self) -> crate::v2_5::types::RequirementOptionsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is the list of current, active Requirements from a Requirement source.  It provides a mechanism for Requirement creators to freely create and publish Tasks without them being included in a planning cycle initiated elsewhere.  When a Requirement creator has created a coherent set of Requirements that is ready for consideration for planning, the Requirements are summarized in this message and published as an indication to the operator or service that initiates planning to include them in the next planning cycle.  The ManagingSystemID element allows a Requirement creator to assign responsibility to its own System or other Systems.  For example, a System could assign planning responsibility for a set of Requirements to a sibling or subordinate System.  When a planning cycle occurs and a Requirement can't be allocated this message/object maintains the current, active To-Do list regardless of planning results from each Requirement source's perspective without relying on MissionPlan, MissionPlanCommand and Requirement states.  Each source of this message is expected to monitor for RequirementCancel requests and removed Requirements accordingly; canceled Requirements should be removed from the RequirementSet list in order to exclude them from the next planning cycle.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RequirementSet(
	pub crate::v2_5::types::RequirementSetMt,
);
impl Deref for RequirementSet {
	type Target = crate::v2_5::types::RequirementSetMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RequirementSet {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RequirementSetMt> for RequirementSet {
	fn as_ref(&self) -> &crate::v2_5::types::RequirementSetMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RequirementSetMt> for RequirementSet {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RequirementSetMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RequirementSetMt> for RequirementSet {
	fn from(p: crate::v2_5::types::RequirementSetMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RequirementSetMt> for RequirementSet {
	fn into(self) -> crate::v2_5::types::RequirementSetMt {
		self.0
	}
}


#[doc = r#"This message represents a request to resend a message or messages packaged within a ResendRequestStatus.  It is intended to support **service/application-level** bootstrapping of newly joining or recovering systems/services; it is not intended to replace similar capabilities at the middleware and/or transport level.  Recipients of the request are generally expected to respond by resending recent instances of the message type that are still currently relevant; an exhaustive resend of all previous instances is not necessarily expected.  This message is not intended to be used for, or result in, messages being sent for the first time.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResendDataRequest(
	pub crate::v2_5::types::ResendDataRequestMt,
);
impl Deref for ResendDataRequest {
	type Target = crate::v2_5::types::ResendDataRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResendDataRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResendDataRequestMt> for ResendDataRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ResendDataRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResendDataRequestMt> for ResendDataRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResendDataRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResendDataRequestMt> for ResendDataRequest {
	fn from(p: crate::v2_5::types::ResendDataRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResendDataRequestMt> for ResendDataRequest {
	fn into(self) -> crate::v2_5::types::ResendDataRequestMt {
		self.0
	}
}


#[doc = r#"This message represents a response to a ResendRequest message.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResendDataRequestStatus(
	pub crate::v2_5::types::ResendDataRequestStatusMt,
);
impl Deref for ResendDataRequestStatus {
	type Target = crate::v2_5::types::ResendDataRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResendDataRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResendDataRequestStatusMt> for ResendDataRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ResendDataRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResendDataRequestStatusMt> for ResendDataRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResendDataRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResendDataRequestStatusMt> for ResendDataRequestStatus {
	fn from(p: crate::v2_5::types::ResendDataRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResendDataRequestStatusMt> for ResendDataRequestStatus {
	fn into(self) -> crate::v2_5::types::ResendDataRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message defines a Response to triggering event or events.  It is effectively a Requirement to "be ready to" 1) instantiate and plan a Requirement (Effect, Action, Task or [Capability]Command tailored to the triggering even, 2) activate a previously created *Plan, 3) issue an alert, 4) do nothing.  Responsibility for the Response can be allocated/assigned to a System via a ResponsePlan that is part of a MissionPlan.  In other words, ResponsePlans allow Responses to be delegated across a SoS.  Activating a ResponsePlan activates monitoring of the triggering events for each of its Responses.  A Response is executing whenever its triggering events are being monitored.  An executing Response causes no changes to the Mission unless a triggering event occurs.  When a triggering event occurs, the options within the Response are evaluated, potentially leading to selection and instantiation of one or options within the Response.

***********************
For Planned C2, evaluating a Response option based on Requirements or *Plans generally means evaluating whole *Plans.  To evaluate a Response option it is generally necessary to create, update, validate, assess and/or score *Plans that include it.  Selecting and activating a Response option generally means approving and activating a *Plan that includes it.
***********************

A Response can continue to execute (triggering events can continue to be monitored) after a Response option has been initiated.  An instantiation of a Response option is detailed in the ResponseActivity message.  Response can be manually initiated via the ResponseCommand message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Response(
	pub crate::v2_5::types::ResponseMt,
);
impl Deref for Response {
	type Target = crate::v2_5::types::ResponseMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Response {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponseMt> for Response {
	fn as_ref(&self) -> &crate::v2_5::types::ResponseMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponseMt> for Response {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponseMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponseMt> for Response {
	fn from(p: crate::v2_5::types::ResponseMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponseMt> for Response {
	fn into(self) -> crate::v2_5::types::ResponseMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the Response Capability of a System.  Response Activities start at the time when monitoring for the triggering event starts.  A given trigger can occur multiple times in the course of a Mission.  Therefore a Response Activity can indicate multiple current and past trigger instances.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponseActivity(
	pub crate::v2_5::types::ResponseActivityMt,
);
impl Deref for ResponseActivity {
	type Target = crate::v2_5::types::ResponseActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponseActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponseActivityMt> for ResponseActivity {
	fn as_ref(&self) -> &crate::v2_5::types::ResponseActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponseActivityMt> for ResponseActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponseActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponseActivityMt> for ResponseActivity {
	fn from(p: crate::v2_5::types::ResponseActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponseActivityMt> for ResponseActivity {
	fn into(self) -> crate::v2_5::types::ResponseActivityMt {
		self.0
	}
}


#[doc = r#"This message is a request to cancel a Response which has been allocated and planned.  A planning input such as Effect, Response, Task and DMPI can't easily be canceled or removed from the System due to race conditions between their various users and publishers, inevitability of the associated activity, etc.  Additionally, the operator or service initiating the cancellation might be different than the one that manages RequirementSets and/or issues *PlanCommand, introducing additional race conditions.  In order to avoid race conditions, receive positive feedback on the success of the cancellation and allow canceled messages/objects to remain in the system for historical purposes, an explicit ResponseCancelCommand is necessary.  A ResponseCancelCommand shall result in the Response being canceled unless execution was already inevitable.  If the Response was inevitable and started executing but can be stopped (such as a long collection Response) it shall cancel as soon as possible.  ResponseCancelCommand shall result in managers of RequirementSets to remove the associated Response, thereby removing the Response from the next planning cycle.  Services other than those that manage RequirementSets and execute activities aren't required to handle ResponseCancelCommand.  ResponseCancelCommand doesn't necessarily trigger a replan (there isn't a corresponding planning trigger), therefore a System could continue to navigate routes related to the canceled Response, even though the Response won't occur.  A subsequent replan could exclude the Response.  Status or feedback for this message is given through ResponseCancelCommandStatus but the resulting status of the Response is given through ResponseStatus.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponseCancelCommand(
	pub crate::v2_5::types::ResponseCancelCommandMt,
);
impl Deref for ResponseCancelCommand {
	type Target = crate::v2_5::types::ResponseCancelCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponseCancelCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponseCancelCommandMt> for ResponseCancelCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ResponseCancelCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponseCancelCommandMt> for ResponseCancelCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponseCancelCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponseCancelCommandMt> for ResponseCancelCommand {
	fn from(p: crate::v2_5::types::ResponseCancelCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponseCancelCommandMt> for ResponseCancelCommand {
	fn into(self) -> crate::v2_5::types::ResponseCancelCommandMt {
		self.0
	}
}


#[doc = r#"This message is sent in response to a ResponseCancelCommand and indicates if the Response was canceled and if not why it was not canceled.  The resulting status of the Response is reported in ResponseStatus.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponseCancelCommandStatus(
	pub crate::v2_5::types::ResponseCancelCommandStatusMt,
);
impl Deref for ResponseCancelCommandStatus {
	type Target = crate::v2_5::types::ResponseCancelCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponseCancelCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponseCancelCommandStatusMt> for ResponseCancelCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ResponseCancelCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponseCancelCommandStatusMt> for ResponseCancelCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponseCancelCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponseCancelCommandStatusMt> for ResponseCancelCommandStatus {
	fn from(p: crate::v2_5::types::ResponseCancelCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponseCancelCommandStatusMt> for ResponseCancelCommandStatus {
	fn into(self) -> crate::v2_5::types::ResponseCancelCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message represents the Response category of UCI Capability.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponseCapability(
	pub crate::v2_5::types::ResponseCapabilityMt,
);
impl Deref for ResponseCapability {
	type Target = crate::v2_5::types::ResponseCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponseCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponseCapabilityMt> for ResponseCapability {
	fn as_ref(&self) -> &crate::v2_5::types::ResponseCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponseCapabilityMt> for ResponseCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponseCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponseCapabilityMt> for ResponseCapability {
	fn from(p: crate::v2_5::types::ResponseCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponseCapabilityMt> for ResponseCapability {
	fn into(self) -> crate::v2_5::types::ResponseCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Response capabilities available to the system.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponseCapabilityStatus(
	pub crate::v2_5::types::ResponseCapabilityStatusMt,
);
impl Deref for ResponseCapabilityStatus {
	type Target = crate::v2_5::types::ResponseCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponseCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponseCapabilityStatusMt> for ResponseCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ResponseCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponseCapabilityStatusMt> for ResponseCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponseCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponseCapabilityStatusMt> for ResponseCapabilityStatus {
	fn from(p: crate::v2_5::types::ResponseCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponseCapabilityStatusMt> for ResponseCapabilityStatus {
	fn into(self) -> crate::v2_5::types::ResponseCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the Response form of the general UCI Capability Command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponseCommand(
	pub crate::v2_5::types::ResponseCommandMt,
);
impl Deref for ResponseCommand {
	type Target = crate::v2_5::types::ResponseCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponseCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponseCommandMt> for ResponseCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ResponseCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponseCommandMt> for ResponseCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponseCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponseCommandMt> for ResponseCommand {
	fn from(p: crate::v2_5::types::ResponseCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponseCommandMt> for ResponseCommand {
	fn into(self) -> crate::v2_5::types::ResponseCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an ResponseCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponseCommandStatus(
	pub crate::v2_5::types::ResponseCommandStatusMt,
);
impl Deref for ResponseCommandStatus {
	type Target = crate::v2_5::types::ResponseCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponseCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponseCommandStatusMt> for ResponseCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ResponseCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponseCommandStatusMt> for ResponseCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponseCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponseCommandStatusMt> for ResponseCommandStatus {
	fn from(p: crate::v2_5::types::ResponseCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponseCommandStatusMt> for ResponseCommandStatus {
	fn into(self) -> crate::v2_5::types::ResponseCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the state of approval for execution of a Response.
***For Responses, "execution" only includes the explicit response management action indicated in the Response message; it does not include subsequent creation of *Plans, execution of Requirements, etc. that may or may not follow.  For example, approval for execution of a Response that includes generation of a Strike Task does not approve the instantiated Strike Task.  It only approves monitoring of the associated Response trigger and initial creation/instantiation of the Strike Task when/if the trigger occurs.***

ApprovalPolicy allow an authority to define policies to approve or reject a Response as it enters execution. Approval may or may not be required. If approval is required, there can be multiple approvers. See Approval* messages for additional details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponseExecutionApprovalStatus(
	pub crate::v2_5::types::ResponseExecutionApprovalStatusMt,
);
impl Deref for ResponseExecutionApprovalStatus {
	type Target = crate::v2_5::types::ResponseExecutionApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponseExecutionApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponseExecutionApprovalStatusMt> for ResponseExecutionApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ResponseExecutionApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponseExecutionApprovalStatusMt> for ResponseExecutionApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponseExecutionApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponseExecutionApprovalStatusMt> for ResponseExecutionApprovalStatus {
	fn from(p: crate::v2_5::types::ResponseExecutionApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponseExecutionApprovalStatusMt> for ResponseExecutionApprovalStatus {
	fn into(self) -> crate::v2_5::types::ResponseExecutionApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies the Responses allocated to a System.  Allocation can be done manually by operators, by an allocation service or a combination.  This message decouples Response allocation from kinematic, action and other types of planning; Response allocations can be created, updated and approved independent of other *Plans.  It enables any type of *Plan to be a constraint on Response allocation.

A ResponsePlan can be an input and/or output of planning processes.  For example the ResponsePlan for the top System in a hierarchical System of System could be an input to a response allocation service that the produces a ResponsePlan per subordinate System with their subset of allocated Responses.

Additional details such as timing, dependencies, decomposition, etc. can be added during the response allocation process and captured in the ResponsePlan to supplement the information in the allocated Responses themselves.

A ResponsePlan can be created discretely or as part of a MissionPlan that includes other *Plans.  A ResponsePlan can only be activated and executed as part of a MissionPlan.  A MissionPlan can be used to plan the execution order of multiple ResponsePlans and *Plans in general.  A ResponsePlan can be subject to approval per Approval* messages.  Planning, approval, activation and execution state information for a ResponsePlan are given in other ResponsePlan* messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponsePlan(
	pub crate::v2_5::types::ResponsePlanMt,
);
impl Deref for ResponsePlan {
	type Target = crate::v2_5::types::ResponsePlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponsePlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponsePlanMt> for ResponsePlan {
	fn as_ref(&self) -> &crate::v2_5::types::ResponsePlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponsePlanMt> for ResponsePlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponsePlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponsePlanMt> for ResponsePlan {
	fn from(p: crate::v2_5::types::ResponsePlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponsePlanMt> for ResponsePlan {
	fn into(self) -> crate::v2_5::types::ResponsePlanMt {
		self.0
	}
}


#[doc = r#"This message indicates status/state of approval for a ResponsePlan.  Approval may or may not be required.  ApprovalPolicy aligned with the *Plans and states of planning allow a planning oversight authority to approve or reject plans as they're created or updated.  Approval may or may not be required.  If required, there may be many approvers.  See Approval* messages for additional details.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponsePlanApprovalStatus(
	pub crate::v2_5::types::ResponsePlanApprovalStatusMt,
);
impl Deref for ResponsePlanApprovalStatus {
	type Target = crate::v2_5::types::ResponsePlanApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponsePlanApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponsePlanApprovalStatusMt> for ResponsePlanApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ResponsePlanApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponsePlanApprovalStatusMt> for ResponsePlanApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponsePlanApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponsePlanApprovalStatusMt> for ResponsePlanApprovalStatus {
	fn from(p: crate::v2_5::types::ResponsePlanApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponsePlanApprovalStatusMt> for ResponsePlanApprovalStatus {
	fn into(self) -> crate::v2_5::types::ResponsePlanApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to perform a response allocation plan process or function. The ResponsePlan message/object is the output of a response allocation plan process or function.  The ResponsePlan output of one response allocation plan process function could be an input to the next function.  UCI enables "discovery" of the response allocation plan processes and functions of a System via the ControlStatus message. This mechanism for discovery empowers a System performing response allocation planning for subordinate Systems of heterogeneous types and/or service/function/process architecture to selectively use, replace or supplement them.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponsePlanCommand(
	pub crate::v2_5::types::ResponsePlanCommandMt,
);
impl Deref for ResponsePlanCommand {
	type Target = crate::v2_5::types::ResponsePlanCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponsePlanCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponsePlanCommandMt> for ResponsePlanCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ResponsePlanCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponsePlanCommandMt> for ResponsePlanCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponsePlanCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponsePlanCommandMt> for ResponsePlanCommand {
	fn from(p: crate::v2_5::types::ResponsePlanCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponsePlanCommandMt> for ResponsePlanCommand {
	fn into(self) -> crate::v2_5::types::ResponsePlanCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to create/update a ResponsePlan, including the current state in a command and processing state machine; see the ResponsePlanCommand message.  Creation/update of a ResponsePlan  may occur autonomously, without a ResponsePlanCommand in which case the current state of the plan could be given in the ResponsePlanStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponsePlanCommandStatus(
	pub crate::v2_5::types::ResponsePlanCommandStatusMt,
);
impl Deref for ResponsePlanCommandStatus {
	type Target = crate::v2_5::types::ResponsePlanCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponsePlanCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponsePlanCommandStatusMt> for ResponsePlanCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ResponsePlanCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponsePlanCommandStatusMt> for ResponsePlanCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponsePlanCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponsePlanCommandStatusMt> for ResponsePlanCommandStatus {
	fn from(p: crate::v2_5::types::ResponsePlanCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponsePlanCommandStatusMt> for ResponsePlanCommandStatus {
	fn into(self) -> crate::v2_5::types::ResponsePlanCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the execution status for one or more ResponsePlans.  Plan execution begins after successful autonomous plan activation or activation via MissionPlanActivation messages.  This message provides execution status regardless of how execution was initiated.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponsePlanExecutionStatus(
	pub crate::v2_5::types::ResponsePlanExecutionStatusMt,
);
impl Deref for ResponsePlanExecutionStatus {
	type Target = crate::v2_5::types::ResponsePlanExecutionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponsePlanExecutionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponsePlanExecutionStatusMt> for ResponsePlanExecutionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ResponsePlanExecutionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponsePlanExecutionStatusMt> for ResponsePlanExecutionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponsePlanExecutionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponsePlanExecutionStatusMt> for ResponsePlanExecutionStatus {
	fn from(p: crate::v2_5::types::ResponsePlanExecutionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponsePlanExecutionStatusMt> for ResponsePlanExecutionStatus {
	fn into(self) -> crate::v2_5::types::ResponsePlanExecutionStatusMt {
		self.0
	}
}


#[doc = r#"Indicates the status/state of a ResponsePlan.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponsePlanStatus(
	pub crate::v2_5::types::ResponsePlanStatusMt,
);
impl Deref for ResponsePlanStatus {
	type Target = crate::v2_5::types::ResponsePlanStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponsePlanStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponsePlanStatusMt> for ResponsePlanStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ResponsePlanStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponsePlanStatusMt> for ResponsePlanStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponsePlanStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponsePlanStatusMt> for ResponsePlanStatus {
	fn from(p: crate::v2_5::types::ResponsePlanStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponsePlanStatusMt> for ResponsePlanStatus {
	fn into(self) -> crate::v2_5::types::ResponsePlanStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the validation, including the current state in a validation state machine, and details of invalid items. Validation may occur periodically, or onesie twosie. See the ResponsePlanValidationCommand message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponsePlanValidation(
	pub crate::v2_5::types::ResponsePlanValidationMt,
);
impl Deref for ResponsePlanValidation {
	type Target = crate::v2_5::types::ResponsePlanValidationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponsePlanValidation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponsePlanValidationMt> for ResponsePlanValidation {
	fn as_ref(&self) -> &crate::v2_5::types::ResponsePlanValidationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponsePlanValidationMt> for ResponsePlanValidation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponsePlanValidationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponsePlanValidationMt> for ResponsePlanValidation {
	fn from(p: crate::v2_5::types::ResponsePlanValidationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponsePlanValidationMt> for ResponsePlanValidation {
	fn into(self) -> crate::v2_5::types::ResponsePlanValidationMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to validate/re-validate an existing ResponsePlan.  It includes an option to modify the Plan to make it valid if it is found to be invalid.  A ResponsePlan can become invalid due to changes in Response timing, weather, order of battle, kinematic movement constraints, operator manual edits and many, many other reasons.  The message allows an existing ResponsePlan to be checked for validity given such changes.  The variables a given planning service, operator or system considers when validating a plan varies.  Different variables might be considered depending on the level of detail of the plan or stage in the overall planning process.  The scope and meaning of "valid" comes from context of the services, operator and systems creating the plan.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponsePlanValidationCommand(
	pub crate::v2_5::types::ResponsePlanValidationCommandMt,
);
impl Deref for ResponsePlanValidationCommand {
	type Target = crate::v2_5::types::ResponsePlanValidationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponsePlanValidationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponsePlanValidationCommandMt> for ResponsePlanValidationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ResponsePlanValidationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponsePlanValidationCommandMt> for ResponsePlanValidationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponsePlanValidationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponsePlanValidationCommandMt> for ResponsePlanValidationCommand {
	fn from(p: crate::v2_5::types::ResponsePlanValidationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponsePlanValidationCommandMt> for ResponsePlanValidationCommand {
	fn into(self) -> crate::v2_5::types::ResponsePlanValidationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to validate a ResponsePlan, including the current state in a command and processing state machine.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponsePlanValidationCommandStatus(
	pub crate::v2_5::types::ResponsePlanValidationCommandStatusMt,
);
impl Deref for ResponsePlanValidationCommandStatus {
	type Target = crate::v2_5::types::ResponsePlanValidationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponsePlanValidationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponsePlanValidationCommandStatusMt> for ResponsePlanValidationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ResponsePlanValidationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponsePlanValidationCommandStatusMt> for ResponsePlanValidationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponsePlanValidationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponsePlanValidationCommandStatusMt> for ResponsePlanValidationCommandStatus {
	fn from(p: crate::v2_5::types::ResponsePlanValidationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponsePlanValidationCommandStatusMt> for ResponsePlanValidationCommandStatus {
	fn into(self) -> crate::v2_5::types::ResponsePlanValidationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message defines planning status of a single Response.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponsePlanningStatus(
	pub crate::v2_5::types::ResponsePlanningStatusMt,
);
impl Deref for ResponsePlanningStatus {
	type Target = crate::v2_5::types::ResponsePlanningStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponsePlanningStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponsePlanningStatusMt> for ResponsePlanningStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ResponsePlanningStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponsePlanningStatusMt> for ResponsePlanningStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponsePlanningStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponsePlanningStatusMt> for ResponsePlanningStatus {
	fn from(p: crate::v2_5::types::ResponsePlanningStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponsePlanningStatusMt> for ResponsePlanningStatus {
	fn into(self) -> crate::v2_5::types::ResponsePlanningStatusMt {
		self.0
	}
}


#[doc = r#"Indicates the execution status for a Response.
***For Responses, "execution" only includes the explicit response management action indicated in the Response message; it does not include subsequent creation of *Plans, execution of Requirements, etc. that may or may not follow.  For example, a Response is executing as soon as its triggers are being monitored.  The triggers may never happen even if the Response is executing.  If a trigger happens, the Response continues to execute but is now "instantiated" once, with details given in the ResponseActivity message.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ResponseStatus(
	pub crate::v2_5::types::ResponseStatusMt,
);
impl Deref for ResponseStatus {
	type Target = crate::v2_5::types::ResponseStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ResponseStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ResponseStatusMt> for ResponseStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ResponseStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ResponseStatusMt> for ResponseStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ResponseStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ResponseStatusMt> for ResponseStatus {
	fn from(p: crate::v2_5::types::ResponseStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ResponseStatusMt> for ResponseStatus {
	fn into(self) -> crate::v2_5::types::ResponseStatusMt {
		self.0
	}
}


#[doc = r#"This message controls the RF use of a Capability.  Control is specified in the form of RF profiles (RF_Profile message).  When multiple profiles are specified, they should be logically ANDed; the Capability is allowed to operate in the intersection the profiles.  A given RF_ControlCommand must always express the full set of profiles for the target Capability.  In other words, RF_ControlCommand is not additive/subtractive; each instance wholly supersedes the previous instance for a given Capability, regardless of whether the CommandID or ObjectState changes.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RfControlCommand(
	pub crate::v2_5::types::RfControlCommandMt,
);
impl Deref for RfControlCommand {
	type Target = crate::v2_5::types::RfControlCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RfControlCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RfControlCommandMt> for RfControlCommand {
	fn as_ref(&self) -> &crate::v2_5::types::RfControlCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RfControlCommandMt> for RfControlCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RfControlCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RfControlCommandMt> for RfControlCommand {
	fn from(p: crate::v2_5::types::RfControlCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RfControlCommandMt> for RfControlCommand {
	fn into(self) -> crate::v2_5::types::RfControlCommandMt {
		self.0
	}
}


#[doc = r#"This message is the response and status to an RF_ControlCommand.  Only the Service which hosts the Capability given in the corresponding RF_ControlCommand should respond with this status message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RfControlCommandStatus(
	pub crate::v2_5::types::RfControlCommandStatusMt,
);
impl Deref for RfControlCommandStatus {
	type Target = crate::v2_5::types::RfControlCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RfControlCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RfControlCommandStatusMt> for RfControlCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RfControlCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RfControlCommandStatusMt> for RfControlCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RfControlCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RfControlCommandStatusMt> for RfControlCommandStatus {
	fn from(p: crate::v2_5::types::RfControlCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RfControlCommandStatusMt> for RfControlCommandStatus {
	fn into(self) -> crate::v2_5::types::RfControlCommandStatusMt {
		self.0
	}
}


#[doc = r#"A profile of either allowed or denied frequencies.  Multiple profiles may be combined to restrict the RF radiation of a capability or individual command.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RfProfile(
	pub crate::v2_5::types::RfProfileMt,
);
impl Deref for RfProfile {
	type Target = crate::v2_5::types::RfProfileMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RfProfile {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RfProfileMt> for RfProfile {
	fn as_ref(&self) -> &crate::v2_5::types::RfProfileMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RfProfileMt> for RfProfile {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RfProfileMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RfProfileMt> for RfProfile {
	fn from(p: crate::v2_5::types::RfProfileMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RfProfileMt> for RfProfile {
	fn into(self) -> crate::v2_5::types::RfProfileMt {
		self.0
	}
}


#[doc = r#"Indicates information about the past, current and/or future RF usage of a Capability.  Use of this message is highly dependent on the performance and RF coordination/deconfliction needs of a given System or System of Systems and is left for specific program related documentation and other System Engineering products to describe.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RfReport(
	pub crate::v2_5::types::RfReportMt,
);
impl Deref for RfReport {
	type Target = crate::v2_5::types::RfReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RfReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RfReportMt> for RfReport {
	fn as_ref(&self) -> &crate::v2_5::types::RfReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RfReportMt> for RfReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RfReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RfReportMt> for RfReport {
	fn from(p: crate::v2_5::types::RfReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RfReportMt> for RfReport {
	fn into(self) -> crate::v2_5::types::RfReportMt {
		self.0
	}
}


#[doc = r#"Provides the current RF resource allocations.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RfResourceAllocation(
	pub crate::v2_5::types::RfResourceAllocationMt,
);
impl Deref for RfResourceAllocation {
	type Target = crate::v2_5::types::RfResourceAllocationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RfResourceAllocation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RfResourceAllocationMt> for RfResourceAllocation {
	fn as_ref(&self) -> &crate::v2_5::types::RfResourceAllocationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RfResourceAllocationMt> for RfResourceAllocation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RfResourceAllocationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RfResourceAllocationMt> for RfResourceAllocation {
	fn from(p: crate::v2_5::types::RfResourceAllocationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RfResourceAllocationMt> for RfResourceAllocation {
	fn into(self) -> crate::v2_5::types::RfResourceAllocationMt {
		self.0
	}
}


#[doc = r#"Used with Shared RF Array systems to request a resource allocation from a Resource Manager. If not sent, the Resource manager bases its resource allocation off the Command and Activity.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RfResourceAllocationRequest(
	pub crate::v2_5::types::RfResourceAllocationRequestMt,
);
impl Deref for RfResourceAllocationRequest {
	type Target = crate::v2_5::types::RfResourceAllocationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RfResourceAllocationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RfResourceAllocationRequestMt> for RfResourceAllocationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::RfResourceAllocationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RfResourceAllocationRequestMt> for RfResourceAllocationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RfResourceAllocationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RfResourceAllocationRequestMt> for RfResourceAllocationRequest {
	fn from(p: crate::v2_5::types::RfResourceAllocationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RfResourceAllocationRequestMt> for RfResourceAllocationRequest {
	fn into(self) -> crate::v2_5::types::RfResourceAllocationRequestMt {
		self.0
	}
}


#[doc = r#"This message is sent from the Resource Manager in response to the RF_ResourceAllocationRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RfResourceAllocationRequestStatus(
	pub crate::v2_5::types::RfResourceAllocationRequestStatusMt,
);
impl Deref for RfResourceAllocationRequestStatus {
	type Target = crate::v2_5::types::RfResourceAllocationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RfResourceAllocationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RfResourceAllocationRequestStatusMt> for RfResourceAllocationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RfResourceAllocationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RfResourceAllocationRequestStatusMt> for RfResourceAllocationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RfResourceAllocationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RfResourceAllocationRequestStatusMt> for RfResourceAllocationRequestStatus {
	fn from(p: crate::v2_5::types::RfResourceAllocationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RfResourceAllocationRequestStatusMt> for RfResourceAllocationRequestStatus {
	fn into(self) -> crate::v2_5::types::RfResourceAllocationRequestStatusMt {
		self.0
	}
}


#[doc = r#"Command used by a subsystem (e.g. EA, ESM) or a centralized beam manager to preload controls on allocated resources.  This command configures the controls for the RFDC components and the Antenna subsystem, and assigns a priority to the requested controls.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RfThreadInstanceSetupCommand(
	pub crate::v2_5::types::RfThreadInstanceSetupCommandMt,
);
impl Deref for RfThreadInstanceSetupCommand {
	type Target = crate::v2_5::types::RfThreadInstanceSetupCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RfThreadInstanceSetupCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RfThreadInstanceSetupCommandMt> for RfThreadInstanceSetupCommand {
	fn as_ref(&self) -> &crate::v2_5::types::RfThreadInstanceSetupCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RfThreadInstanceSetupCommandMt> for RfThreadInstanceSetupCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RfThreadInstanceSetupCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RfThreadInstanceSetupCommandMt> for RfThreadInstanceSetupCommand {
	fn from(p: crate::v2_5::types::RfThreadInstanceSetupCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RfThreadInstanceSetupCommandMt> for RfThreadInstanceSetupCommand {
	fn into(self) -> crate::v2_5::types::RfThreadInstanceSetupCommandMt {
		self.0
	}
}


#[doc = r#"Command used by Antenna and RFDC subsystems to acknowledge the preloaded controls on allocated resources that were sent by the subsystem (e.g. EA, ESM).UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RfThreadInstanceSetupCommandStatus(
	pub crate::v2_5::types::RfThreadInstanceSetupCommandStatusMt,
);
impl Deref for RfThreadInstanceSetupCommandStatus {
	type Target = crate::v2_5::types::RfThreadInstanceSetupCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RfThreadInstanceSetupCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RfThreadInstanceSetupCommandStatusMt> for RfThreadInstanceSetupCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RfThreadInstanceSetupCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RfThreadInstanceSetupCommandStatusMt> for RfThreadInstanceSetupCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RfThreadInstanceSetupCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RfThreadInstanceSetupCommandStatusMt> for RfThreadInstanceSetupCommandStatus {
	fn from(p: crate::v2_5::types::RfThreadInstanceSetupCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RfThreadInstanceSetupCommandStatusMt> for RfThreadInstanceSetupCommandStatus {
	fn into(self) -> crate::v2_5::types::RfThreadInstanceSetupCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies planned activities for a System with a RoutePlan.  A "Route Activity" is any *Capability-related activity planned in context of the kinematic RoutePlan of the System.  Activities are the planned implementation details of Effects, Actions, Tasks, Capability Commands, etc.  Route activity planning can be done manually by operators, by an activity planning service or a combination.  This message decouples activity planning from allocation, kinematic and other types of planning; the RouteActivityPlan of a System can be created, updated and approved independent of other *Plans.  It enables any type of *Plan to be a constraint on activity planning.
A RouteActivityPlan can be an input and/or output of planning processes.  For example a RouteActivityPlan from a previous round of planning could be an input to an activity planning service that adds additional planned activities to it.

A single System can have multiple independent RouteActivityPlans for different Task, Capability, sensor, etc. types; that are developed by one or more services across a multi-System service oriented architecture; at different times then independently updated and approved.  Optionally, all types of activities for a System can be included in a single RouteActivityPlan.

A RouteActivityPlan can be created discretely or as part of a MissionPlan that includes other *Plans.  A RouteActivityPlan can only be activated and executed as part of a MissionPlan.  A MissionPlan can be used to plan the execution order of multiple RouteActivityPlans and *Plans in general.  A RouteActivityPlan can be subject to approval per Approval* messages.  Planning, approval, activation and execution state information for a RouteActivityPlan are given in other RouteActivityPlan* messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteActivityPlan(
	pub crate::v2_5::types::RouteActivityPlanMt,
);
impl Deref for RouteActivityPlan {
	type Target = crate::v2_5::types::RouteActivityPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteActivityPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteActivityPlanMt> for RouteActivityPlan {
	fn as_ref(&self) -> &crate::v2_5::types::RouteActivityPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteActivityPlanMt> for RouteActivityPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteActivityPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteActivityPlanMt> for RouteActivityPlan {
	fn from(p: crate::v2_5::types::RouteActivityPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteActivityPlanMt> for RouteActivityPlan {
	fn into(self) -> crate::v2_5::types::RouteActivityPlanMt {
		self.0
	}
}


#[doc = r#"This message indicates state of approval for a RouteActivityPlan.  Approval may or may not be required.  ApprovalPolicy aligned with the *Plans and states of planning allow a planning oversight authority to approve or reject plans as they're created or updated.  Approval may or may not be required.  If required, there may be many approvers.  See Approval* messages for additional details.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteActivityPlanApprovalStatus(
	pub crate::v2_5::types::RouteActivityPlanApprovalStatusMt,
);
impl Deref for RouteActivityPlanApprovalStatus {
	type Target = crate::v2_5::types::RouteActivityPlanApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteActivityPlanApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteActivityPlanApprovalStatusMt> for RouteActivityPlanApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RouteActivityPlanApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteActivityPlanApprovalStatusMt> for RouteActivityPlanApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteActivityPlanApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteActivityPlanApprovalStatusMt> for RouteActivityPlanApprovalStatus {
	fn from(p: crate::v2_5::types::RouteActivityPlanApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteActivityPlanApprovalStatusMt> for RouteActivityPlanApprovalStatus {
	fn into(self) -> crate::v2_5::types::RouteActivityPlanApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message invokes a RouteActivityPlan planning process.  Each planning process is declared with a unique ID in the ControlStatus message; that ID is used in this message to invoke the process.  The message includes many inputs to the planning process but many others may come from a variety of other messages.  A few examples of the many inputs include:

1. Options for constraining the planning function in a variety of ways using existing Plans of the same type or by other Plan types.  For example, a RouteActivityPlan could be constrained by an existing kinematic RoutePlan, a previous RouteActivityPlan and/or a TaskPlan.

2. Environment overrides to selectively modify details of the current planning environment in the context of a single planning command. For example, a known threat Entity in the environment could be removed and an expected Entity could be for added to the environment in the context of a single planning command in support of "what-if" planning.

3. "Weightings" that influence the decisions of operators or planning algorithms performing the planning.

4. Temporal and/or kinematic begin and end points.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteActivityPlanCommand(
	pub crate::v2_5::types::RouteActivityPlanCommandMt,
);
impl Deref for RouteActivityPlanCommand {
	type Target = crate::v2_5::types::RouteActivityPlanCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteActivityPlanCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteActivityPlanCommandMt> for RouteActivityPlanCommand {
	fn as_ref(&self) -> &crate::v2_5::types::RouteActivityPlanCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteActivityPlanCommandMt> for RouteActivityPlanCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteActivityPlanCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteActivityPlanCommandMt> for RouteActivityPlanCommand {
	fn from(p: crate::v2_5::types::RouteActivityPlanCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteActivityPlanCommandMt> for RouteActivityPlanCommand {
	fn into(self) -> crate::v2_5::types::RouteActivityPlanCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to create/update a RouteActivityPlan, including the current state in a command and processing state machine; see the RouteActivityPlanCommand message.  Creation/update of a RouteActivityPlan  may occur autonomously, without a RouteActivityPlanCommand in which case the current state of the plan could be given in the RouteActivityPlanStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteActivityPlanCommandStatus(
	pub crate::v2_5::types::RouteActivityPlanCommandStatusMt,
);
impl Deref for RouteActivityPlanCommandStatus {
	type Target = crate::v2_5::types::RouteActivityPlanCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteActivityPlanCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteActivityPlanCommandStatusMt> for RouteActivityPlanCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RouteActivityPlanCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteActivityPlanCommandStatusMt> for RouteActivityPlanCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteActivityPlanCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteActivityPlanCommandStatusMt> for RouteActivityPlanCommandStatus {
	fn from(p: crate::v2_5::types::RouteActivityPlanCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteActivityPlanCommandStatusMt> for RouteActivityPlanCommandStatus {
	fn into(self) -> crate::v2_5::types::RouteActivityPlanCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the execution status for one or more RouteActivityPlans.  Plan execution begins after successful autonomous plan activation or activation via MissionPlanActivation messages.  This message provides execution status regardless of how execution was initiated.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteActivityPlanExecutionStatus(
	pub crate::v2_5::types::RouteActivityPlanExecutionStatusMt,
);
impl Deref for RouteActivityPlanExecutionStatus {
	type Target = crate::v2_5::types::RouteActivityPlanExecutionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteActivityPlanExecutionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteActivityPlanExecutionStatusMt> for RouteActivityPlanExecutionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RouteActivityPlanExecutionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteActivityPlanExecutionStatusMt> for RouteActivityPlanExecutionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteActivityPlanExecutionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteActivityPlanExecutionStatusMt> for RouteActivityPlanExecutionStatus {
	fn from(p: crate::v2_5::types::RouteActivityPlanExecutionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteActivityPlanExecutionStatusMt> for RouteActivityPlanExecutionStatus {
	fn into(self) -> crate::v2_5::types::RouteActivityPlanExecutionStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the current state in a planning and plan validation state machine for a RouteActivityPlan.  Planning and validation may occur autonomously or be commanded.  In the former case, there is no command status message indicating the resulting state.  This message provides current status regardless of how status changes were triggered.  This message is not to be used to status individual actions within the RouteActivityPlan, only the whole plan.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteActivityPlanStatus(
	pub crate::v2_5::types::RouteActivityPlanStatusMt,
);
impl Deref for RouteActivityPlanStatus {
	type Target = crate::v2_5::types::RouteActivityPlanStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteActivityPlanStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteActivityPlanStatusMt> for RouteActivityPlanStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RouteActivityPlanStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteActivityPlanStatusMt> for RouteActivityPlanStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteActivityPlanStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteActivityPlanStatusMt> for RouteActivityPlanStatus {
	fn from(p: crate::v2_5::types::RouteActivityPlanStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteActivityPlanStatusMt> for RouteActivityPlanStatus {
	fn into(self) -> crate::v2_5::types::RouteActivityPlanStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the validation, including the current state in a validation state machine, and details of invalid items. Validation may occur periodically, or onesie twosie. See the RouteActivityPlanValidationCommand message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteActivityPlanValidation(
	pub crate::v2_5::types::RouteActivityPlanValidationMt,
);
impl Deref for RouteActivityPlanValidation {
	type Target = crate::v2_5::types::RouteActivityPlanValidationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteActivityPlanValidation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteActivityPlanValidationMt> for RouteActivityPlanValidation {
	fn as_ref(&self) -> &crate::v2_5::types::RouteActivityPlanValidationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteActivityPlanValidationMt> for RouteActivityPlanValidation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteActivityPlanValidationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteActivityPlanValidationMt> for RouteActivityPlanValidation {
	fn from(p: crate::v2_5::types::RouteActivityPlanValidationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteActivityPlanValidationMt> for RouteActivityPlanValidation {
	fn into(self) -> crate::v2_5::types::RouteActivityPlanValidationMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to validate/re-validate an existing RouteActivityPlan.  It includes an option to modify the Plan to make it valid if it is found to be invalid.  A RouteActivityPlan can become invalid due to changes in Task timing, weather, order of battle, kinematic movement constraints, operator manual edits and many, many other reasons.  The message allows an existing RouteActivityPlan to be checked for validity given such changes.  The variables a given planning service, operator or system considers when validating a plan varies.  Different variables might be considered depending on the level of detail of the plan or stage in the overall planning process.  The scope and meaning of "valid" comes from context of the services, operator and systems creating the plan.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteActivityPlanValidationCommand(
	pub crate::v2_5::types::RouteActivityPlanValidationCommandMt,
);
impl Deref for RouteActivityPlanValidationCommand {
	type Target = crate::v2_5::types::RouteActivityPlanValidationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteActivityPlanValidationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteActivityPlanValidationCommandMt> for RouteActivityPlanValidationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::RouteActivityPlanValidationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteActivityPlanValidationCommandMt> for RouteActivityPlanValidationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteActivityPlanValidationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteActivityPlanValidationCommandMt> for RouteActivityPlanValidationCommand {
	fn from(p: crate::v2_5::types::RouteActivityPlanValidationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteActivityPlanValidationCommandMt> for RouteActivityPlanValidationCommand {
	fn into(self) -> crate::v2_5::types::RouteActivityPlanValidationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to validate a RouteActivityPlan, including the current state in a command and processing state machine.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteActivityPlanValidationCommandStatus(
	pub crate::v2_5::types::RouteActivityPlanValidationCommandStatusMt,
);
impl Deref for RouteActivityPlanValidationCommandStatus {
	type Target = crate::v2_5::types::RouteActivityPlanValidationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteActivityPlanValidationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteActivityPlanValidationCommandStatusMt> for RouteActivityPlanValidationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RouteActivityPlanValidationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteActivityPlanValidationCommandStatusMt> for RouteActivityPlanValidationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteActivityPlanValidationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteActivityPlanValidationCommandStatusMt> for RouteActivityPlanValidationCommandStatus {
	fn from(p: crate::v2_5::types::RouteActivityPlanValidationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteActivityPlanValidationCommandStatusMt> for RouteActivityPlanValidationCommandStatus {
	fn into(self) -> crate::v2_5::types::RouteActivityPlanValidationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message provides metrics on predicted performance details of a route plan and/or corresponding route action plan. Metrics may be provided for any combination of parts for the route or route action plans (e.g. provide metrics for all TASKS in RouteActivityPlan A for the INGRESS and EGRESS parts of RoutePlanA). Metrics categories include endurance (e.g. fuel), expendables (e.g. flares), and Weapons (e.g. missiles). This message is intended for use prior to execution of a plan; for actual results of the plan, systems should use those status and activity messages produced during execution to derive metrics.

The intent of the *Plan Metrics messages are to provide calculated metrics that are based on existing plan input data. This is to continue the current paradigm of how metrics were represented in existing/previous MissionPlan and other sub plans. There is a distinction between the *Plan Metrics and the Assessment message, in that Assessment gives much more specific data and can consider other supporting systems and their capabilities in the assessment.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteMetrics(
	pub crate::v2_5::types::RouteMetricsMt,
);
impl Deref for RouteMetrics {
	type Target = crate::v2_5::types::RouteMetricsMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteMetrics {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteMetricsMt> for RouteMetrics {
	fn as_ref(&self) -> &crate::v2_5::types::RouteMetricsMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteMetricsMt> for RouteMetrics {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteMetricsMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteMetricsMt> for RouteMetrics {
	fn from(p: crate::v2_5::types::RouteMetricsMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteMetricsMt> for RouteMetrics {
	fn into(self) -> crate::v2_5::types::RouteMetricsMt {
		self.0
	}
}


#[doc = r#"This message requests the generation of route metrics for a specific route plan and, optionally, its associated route action plan and/or action parts. For details on what metrics are provided, see RouteMetrics.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteMetricsRequest(
	pub crate::v2_5::types::RouteMetricsRequestMt,
);
impl Deref for RouteMetricsRequest {
	type Target = crate::v2_5::types::RouteMetricsRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteMetricsRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteMetricsRequestMt> for RouteMetricsRequest {
	fn as_ref(&self) -> &crate::v2_5::types::RouteMetricsRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteMetricsRequestMt> for RouteMetricsRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteMetricsRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteMetricsRequestMt> for RouteMetricsRequest {
	fn from(p: crate::v2_5::types::RouteMetricsRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteMetricsRequestMt> for RouteMetricsRequest {
	fn into(self) -> crate::v2_5::types::RouteMetricsRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status of a RouteMetricsRequest received by the applicable C2 system. In the event that metric reporting was incomplete, this message should provide details on why the process was unsuccessful.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteMetricsRequestStatus(
	pub crate::v2_5::types::RouteMetricsRequestStatusMt,
);
impl Deref for RouteMetricsRequestStatus {
	type Target = crate::v2_5::types::RouteMetricsRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteMetricsRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteMetricsRequestStatusMt> for RouteMetricsRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RouteMetricsRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteMetricsRequestStatusMt> for RouteMetricsRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteMetricsRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteMetricsRequestStatusMt> for RouteMetricsRequestStatus {
	fn from(p: crate::v2_5::types::RouteMetricsRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteMetricsRequestStatusMt> for RouteMetricsRequestStatus {
	fn into(self) -> crate::v2_5::types::RouteMetricsRequestStatusMt {
		self.0
	}
}


#[doc = r#"This is a message to request a Route modification, which allows requests for atomic changes to a Route plan outside of normal mission/orbit planning, where transmission of whole plans could be an issue. The status of each request is reported in the RouteModificationRequestStatus message. The result of a completed request is a new RoutePlan message incorporating the modifications and incrementing the RouteVersionID.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteModificationRequest(
	pub crate::v2_5::types::RouteModificationRequestMt,
);
impl Deref for RouteModificationRequest {
	type Target = crate::v2_5::types::RouteModificationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteModificationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteModificationRequestMt> for RouteModificationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::RouteModificationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteModificationRequestMt> for RouteModificationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteModificationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteModificationRequestMt> for RouteModificationRequest {
	fn from(p: crate::v2_5::types::RouteModificationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteModificationRequestMt> for RouteModificationRequest {
	fn into(self) -> crate::v2_5::types::RouteModificationRequestMt {
		self.0
	}
}


#[doc = r#"This is a message to report status on a RouteModificationRequest. A successful modification request should result in a new RoutePlan message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RouteModificationRequestStatus(
	pub crate::v2_5::types::RouteModificationRequestStatusMt,
);
impl Deref for RouteModificationRequestStatus {
	type Target = crate::v2_5::types::RouteModificationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RouteModificationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RouteModificationRequestStatusMt> for RouteModificationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RouteModificationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RouteModificationRequestStatusMt> for RouteModificationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RouteModificationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RouteModificationRequestStatusMt> for RouteModificationRequestStatus {
	fn from(p: crate::v2_5::types::RouteModificationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RouteModificationRequestStatusMt> for RouteModificationRequestStatus {
	fn into(self) -> crate::v2_5::types::RouteModificationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies the planned kinematic route of a System.  "Route" is defined as a series of WGS-84 waypoints and is intended for Systems such as aircraft and ground vehicles whose kinematic plans are best represented in an Earth-centered rotational frame.  Route planning can be done manually by operators, by a route planning service or a combination.  This message decouples kinematic planning from allocation, action and other types of planning; the kinematic RoutePlan of a System can be created, updated and approved independent of other *Plans.  It enables any type of *Plan to be a constraint on route planning.

A RoutePlan can be an input and/or output of planning processes.  For example a coarse RoutePlan created by the top System in a hierarchical System of System for overall Mission orchestration and deconfliction could be an input to a route planning service that the produces a detailed, flyable RoutePlan for a specific subordinate System.

A single System can have multiple independent RoutePlans for different types of planned routes such as primary, ingress, egress and contingency.  The different types of routes can be developed by one or more services across a multi-System service oriented architecture at different times then independently updated and approved.  Optionally, all types of routes for a System can be included in a single RoutePlan.

A RoutePlan can be created discretely or as part of a MissionPlan that includes other *Plans.  A RoutePlan can only be activated and executed as part of a MissionPlan.  A MissionPlan can be used to plan the execution order of multiple RoutePlans and *Plans in general.  A RoutePlan can be subject to approval per Approval* messages.  Planning, approval, activation and execution state information for a RoutePlan are given in other RoutePlan* messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RoutePlan(
	pub crate::v2_5::types::RoutePlanMt,
);
impl Deref for RoutePlan {
	type Target = crate::v2_5::types::RoutePlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RoutePlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RoutePlanMt> for RoutePlan {
	fn as_ref(&self) -> &crate::v2_5::types::RoutePlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RoutePlanMt> for RoutePlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RoutePlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RoutePlanMt> for RoutePlan {
	fn from(p: crate::v2_5::types::RoutePlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RoutePlanMt> for RoutePlan {
	fn into(self) -> crate::v2_5::types::RoutePlanMt {
		self.0
	}
}


#[doc = r#"This message indicates status/state of approval for a RoutePlan.  Approval may or may not be required.  ApprovalPolicy aligned with the *Plans and states of planning allow a planning oversight authority to approve or reject plans as they're created or updated.  Approval may or may not be required.  If required, there may be many approvers.  See Approval* messages for additional details.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RoutePlanApprovalStatus(
	pub crate::v2_5::types::RoutePlanApprovalStatusMt,
);
impl Deref for RoutePlanApprovalStatus {
	type Target = crate::v2_5::types::RoutePlanApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RoutePlanApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RoutePlanApprovalStatusMt> for RoutePlanApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RoutePlanApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RoutePlanApprovalStatusMt> for RoutePlanApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RoutePlanApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RoutePlanApprovalStatusMt> for RoutePlanApprovalStatus {
	fn from(p: crate::v2_5::types::RoutePlanApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RoutePlanApprovalStatusMt> for RoutePlanApprovalStatus {
	fn into(self) -> crate::v2_5::types::RoutePlanApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message invokes a RoutePlan planning process.  Each planning process is declared with a unique ID in the ControlStatus message; that ID is used in this message to invoke the process.  The message includes many inputs to the planning process but many others may come from a variety of other messages.  A few examples of the many inputs include:

1. Options for constraining the planning function in a variety of ways using existing Plans of the same type or by other Plan types.  For example, a RoutePlan could be constrained by a previous RoutePlan, a previous RouteActivityPlan and/or a TaskPlan.

2. Environment overrides to selectively modify details of the current planning environment in the context of a single planning command. For example, a known threat Entity in the environment could be removed and an expected Entity could be added to the environment in the context of a single planning command in support of "what-if" planning.

3. "Weightings" that influence the decisions of operators or planning algorithms performing the planning.

4. Temporal and/or kinematic begin and end points.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RoutePlanCommand(
	pub crate::v2_5::types::RoutePlanCommandMt,
);
impl Deref for RoutePlanCommand {
	type Target = crate::v2_5::types::RoutePlanCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RoutePlanCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RoutePlanCommandMt> for RoutePlanCommand {
	fn as_ref(&self) -> &crate::v2_5::types::RoutePlanCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RoutePlanCommandMt> for RoutePlanCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RoutePlanCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RoutePlanCommandMt> for RoutePlanCommand {
	fn from(p: crate::v2_5::types::RoutePlanCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RoutePlanCommandMt> for RoutePlanCommand {
	fn into(self) -> crate::v2_5::types::RoutePlanCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to create/update a RoutePlan, including the current state in a command and processing state machine; see the RoutePlanCommand message.  Creation/update of a RoutePlan  may occur autonomously, without a RoutePlanCommand in which case the current state of the plan could be given in the RoutePlanStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RoutePlanCommandStatus(
	pub crate::v2_5::types::RoutePlanCommandStatusMt,
);
impl Deref for RoutePlanCommandStatus {
	type Target = crate::v2_5::types::RoutePlanCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RoutePlanCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RoutePlanCommandStatusMt> for RoutePlanCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RoutePlanCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RoutePlanCommandStatusMt> for RoutePlanCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RoutePlanCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RoutePlanCommandStatusMt> for RoutePlanCommandStatus {
	fn from(p: crate::v2_5::types::RoutePlanCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RoutePlanCommandStatusMt> for RoutePlanCommandStatus {
	fn into(self) -> crate::v2_5::types::RoutePlanCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the execution status for one or more RoutePlans.  Plan execution begins after successful autonomous plan activation or activation via MissionPlanActivation messages.  This message provides execution status regardless of how execution was initiated.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RoutePlanExecutionStatus(
	pub crate::v2_5::types::RoutePlanExecutionStatusMt,
);
impl Deref for RoutePlanExecutionStatus {
	type Target = crate::v2_5::types::RoutePlanExecutionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RoutePlanExecutionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RoutePlanExecutionStatusMt> for RoutePlanExecutionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RoutePlanExecutionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RoutePlanExecutionStatusMt> for RoutePlanExecutionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RoutePlanExecutionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RoutePlanExecutionStatusMt> for RoutePlanExecutionStatus {
	fn from(p: crate::v2_5::types::RoutePlanExecutionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RoutePlanExecutionStatusMt> for RoutePlanExecutionStatus {
	fn into(self) -> crate::v2_5::types::RoutePlanExecutionStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the current state in a planning and plan validation state machine for a RoutePlan.  Planning and validation may occur autonomously or be commanded.  In the former case, there is no command status message indicating the resulting state.  This message provides current status regardless of how status changes were triggered.  This message is not to be used to status individual actions within the RoutePlan, only the whole plan.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RoutePlanStatus(
	pub crate::v2_5::types::RoutePlanStatusMt,
);
impl Deref for RoutePlanStatus {
	type Target = crate::v2_5::types::RoutePlanStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RoutePlanStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RoutePlanStatusMt> for RoutePlanStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RoutePlanStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RoutePlanStatusMt> for RoutePlanStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RoutePlanStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RoutePlanStatusMt> for RoutePlanStatus {
	fn from(p: crate::v2_5::types::RoutePlanStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RoutePlanStatusMt> for RoutePlanStatus {
	fn into(self) -> crate::v2_5::types::RoutePlanStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the validation, including the current state in a validation state machine, and details of invalid items. Validation may occur periodically, or onesie twosie. See the RoutePlanValidationCommand message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RoutePlanValidation(
	pub crate::v2_5::types::RoutePlanValidationMt,
);
impl Deref for RoutePlanValidation {
	type Target = crate::v2_5::types::RoutePlanValidationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RoutePlanValidation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RoutePlanValidationMt> for RoutePlanValidation {
	fn as_ref(&self) -> &crate::v2_5::types::RoutePlanValidationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RoutePlanValidationMt> for RoutePlanValidation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RoutePlanValidationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RoutePlanValidationMt> for RoutePlanValidation {
	fn from(p: crate::v2_5::types::RoutePlanValidationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RoutePlanValidationMt> for RoutePlanValidation {
	fn into(self) -> crate::v2_5::types::RoutePlanValidationMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to validate/re-validate an existing RoutePlan.  It includes an option to modify the Plan to make it valid if it is found to be invalid.  A RoutePlan can become invalid due to changes in Task timing, weather, order of battle, kinematic movement constraints, operator manual edits and many, many other reasons.  The message allows an existing RoutePlan to be checked for validity given such changes.  The variables a given planning service, operator or system considers when validating a plan varies.  Different variables might be considered depending on the level of detail of the plan or stage in the overall planning process.  The scope and meaning of "valid" comes from context of the services, operator and systems creating the plan.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RoutePlanValidationCommand(
	pub crate::v2_5::types::RoutePlanValidationCommandMt,
);
impl Deref for RoutePlanValidationCommand {
	type Target = crate::v2_5::types::RoutePlanValidationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RoutePlanValidationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RoutePlanValidationCommandMt> for RoutePlanValidationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::RoutePlanValidationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RoutePlanValidationCommandMt> for RoutePlanValidationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RoutePlanValidationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RoutePlanValidationCommandMt> for RoutePlanValidationCommand {
	fn from(p: crate::v2_5::types::RoutePlanValidationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RoutePlanValidationCommandMt> for RoutePlanValidationCommand {
	fn into(self) -> crate::v2_5::types::RoutePlanValidationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to validate a RoutePlan, including the current state in a command and processing state machine.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct RoutePlanValidationCommandStatus(
	pub crate::v2_5::types::RoutePlanValidationCommandStatusMt,
);
impl Deref for RoutePlanValidationCommandStatus {
	type Target = crate::v2_5::types::RoutePlanValidationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for RoutePlanValidationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::RoutePlanValidationCommandStatusMt> for RoutePlanValidationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::RoutePlanValidationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::RoutePlanValidationCommandStatusMt> for RoutePlanValidationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::RoutePlanValidationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::RoutePlanValidationCommandStatusMt> for RoutePlanValidationCommandStatus {
	fn from(p: crate::v2_5::types::RoutePlanValidationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::RoutePlanValidationCommandStatusMt> for RoutePlanValidationCommandStatus {
	fn into(self) -> crate::v2_5::types::RoutePlanValidationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the SAR Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (SAR_Command) from an Operator or Capability management Service, 3) currently in-work SAR, 4) SAR scheduled for the future and 5) SAR that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single SAR_Command or other triggering event can result in multiple activities within the SAR_Activity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SarActivity(
	pub crate::v2_5::types::SarActivityMt,
);
impl Deref for SarActivity {
	type Target = crate::v2_5::types::SarActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SarActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SarActivityMt> for SarActivity {
	fn as_ref(&self) -> &crate::v2_5::types::SarActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SarActivityMt> for SarActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SarActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SarActivityMt> for SarActivity {
	fn from(p: crate::v2_5::types::SarActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SarActivityMt> for SarActivity {
	fn into(self) -> crate::v2_5::types::SarActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the SAR (Synthetic Aperture Radar) form of UCI Capability.  This message "advertises" the mostly static characteristics of a mission-ready SAR Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SarCapability(
	pub crate::v2_5::types::SarCapabilityMt,
);
impl Deref for SarCapability {
	type Target = crate::v2_5::types::SarCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SarCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SarCapabilityMt> for SarCapability {
	fn as_ref(&self) -> &crate::v2_5::types::SarCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SarCapabilityMt> for SarCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SarCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SarCapabilityMt> for SarCapability {
	fn from(p: crate::v2_5::types::SarCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SarCapabilityMt> for SarCapability {
	fn into(self) -> crate::v2_5::types::SarCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the SAR capabilities.   This includes whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SarCapabilityStatus(
	pub crate::v2_5::types::SarCapabilityStatusMt,
);
impl Deref for SarCapabilityStatus {
	type Target = crate::v2_5::types::SarCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SarCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SarCapabilityStatusMt> for SarCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SarCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SarCapabilityStatusMt> for SarCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SarCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SarCapabilityStatusMt> for SarCapabilityStatus {
	fn from(p: crate::v2_5::types::SarCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SarCapabilityStatusMt> for SarCapabilityStatus {
	fn into(self) -> crate::v2_5::types::SarCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the SAR (Synthetic Aperture Radar) form of the general UCI Capability Command.  It is used to manually invoke a SAR Capability to perform a new SAR Activity or change an existing interactive SAR Activity.  It differs from a SAR Task because it is intended for direct interaction with the host of the Capability, not a planning Service, and therefore is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan.  Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages.  Capability Commands can be used in parallel with Tasks, but are generally deferential to them.  However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SarCommand(
	pub crate::v2_5::types::SarCommandMt,
);
impl Deref for SarCommand {
	type Target = crate::v2_5::types::SarCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SarCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SarCommandMt> for SarCommand {
	fn as_ref(&self) -> &crate::v2_5::types::SarCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SarCommandMt> for SarCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SarCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SarCommandMt> for SarCommand {
	fn from(p: crate::v2_5::types::SarCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SarCommandMt> for SarCommand {
	fn into(self) -> crate::v2_5::types::SarCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of a SAR_Command.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the SAR_Activity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SarCommandStatus(
	pub crate::v2_5::types::SarCommandStatusMt,
);
impl Deref for SarCommandStatus {
	type Target = crate::v2_5::types::SarCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SarCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SarCommandStatusMt> for SarCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SarCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SarCommandStatusMt> for SarCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SarCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SarCommandStatusMt> for SarCommandStatus {
	fn from(p: crate::v2_5::types::SarCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SarCommandStatusMt> for SarCommandStatus {
	fn into(self) -> crate::v2_5::types::SarCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the SAR Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SarSettingsCommand(
	pub crate::v2_5::types::SarSettingsCommandMt,
);
impl Deref for SarSettingsCommand {
	type Target = crate::v2_5::types::SarSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SarSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SarSettingsCommandMt> for SarSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::SarSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SarSettingsCommandMt> for SarSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SarSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SarSettingsCommandMt> for SarSettingsCommand {
	fn from(p: crate::v2_5::types::SarSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SarSettingsCommandMt> for SarSettingsCommand {
	fn into(self) -> crate::v2_5::types::SarSettingsCommandMt {
		self.0
	}
}


#[doc = r#"Reports the acknowledgment and/or acceptance of a SAR settings command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SarSettingsCommandStatus(
	pub crate::v2_5::types::SarSettingsCommandStatusMt,
);
impl Deref for SarSettingsCommandStatus {
	type Target = crate::v2_5::types::SarSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SarSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SarSettingsCommandStatusMt> for SarSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SarSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SarSettingsCommandStatusMt> for SarSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SarSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SarSettingsCommandStatusMt> for SarSettingsCommandStatus {
	fn from(p: crate::v2_5::types::SarSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SarSettingsCommandStatusMt> for SarSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::SarSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message contains a representation of an Sea-Subsurface (Equipment) Record within an Order of Battle.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SeaSubsurfaceRecord(
	pub crate::v2_5::types::SeaSubsurfaceRecordMt,
);
impl Deref for SeaSubsurfaceRecord {
	type Target = crate::v2_5::types::SeaSubsurfaceRecordMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SeaSubsurfaceRecord {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SeaSubsurfaceRecordMt> for SeaSubsurfaceRecord {
	fn as_ref(&self) -> &crate::v2_5::types::SeaSubsurfaceRecordMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SeaSubsurfaceRecordMt> for SeaSubsurfaceRecord {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SeaSubsurfaceRecordMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SeaSubsurfaceRecordMt> for SeaSubsurfaceRecord {
	fn from(p: crate::v2_5::types::SeaSubsurfaceRecordMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SeaSubsurfaceRecordMt> for SeaSubsurfaceRecord {
	fn into(self) -> crate::v2_5::types::SeaSubsurfaceRecordMt {
		self.0
	}
}


#[doc = r#"This message contains a representation of an Sea-Surface (Equipment) Record within an Order of Battle.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SeaSurfaceRecord(
	pub crate::v2_5::types::SeaSurfaceRecordMt,
);
impl Deref for SeaSurfaceRecord {
	type Target = crate::v2_5::types::SeaSurfaceRecordMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SeaSurfaceRecord {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SeaSurfaceRecordMt> for SeaSurfaceRecord {
	fn as_ref(&self) -> &crate::v2_5::types::SeaSurfaceRecordMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SeaSurfaceRecordMt> for SeaSurfaceRecord {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SeaSurfaceRecordMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SeaSurfaceRecordMt> for SeaSurfaceRecord {
	fn from(p: crate::v2_5::types::SeaSurfaceRecordMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SeaSurfaceRecordMt> for SeaSurfaceRecord {
	fn into(self) -> crate::v2_5::types::SeaSurfaceRecordMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the self defense capabilities available to the system.   This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, and quantities of self defense capabilities.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SelfDefenseStatus(
	pub crate::v2_5::types::SelfDefenseStatusMt,
);
impl Deref for SelfDefenseStatus {
	type Target = crate::v2_5::types::SelfDefenseStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SelfDefenseStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SelfDefenseStatusMt> for SelfDefenseStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SelfDefenseStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SelfDefenseStatusMt> for SelfDefenseStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SelfDefenseStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SelfDefenseStatusMt> for SelfDefenseStatus {
	fn from(p: crate::v2_5::types::SelfDefenseStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SelfDefenseStatusMt> for SelfDefenseStatus {
	fn into(self) -> crate::v2_5::types::SelfDefenseStatusMt {
		self.0
	}
}


#[doc = r#"This message can be made in two ways. First, it could indicate a desire to apply a configuration parameter to a specified service. In this case, ServiceConfigurationChangeRequestID represents the transaction ID for the configuration Request. In the second form, it could represent a broadcast request to all services to react to a change to an affected item. For instance, if a configuration parameter request is made to a service, the service may respond that the configuration change was made successfully, but a configuration item was affected. This affected item would then be broadcast back to all services, which may be forced to re-process the configuration item.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceConfigurationChangeRequest(
	pub crate::v2_5::types::ServiceConfigurationChangeRequestMt,
);
impl Deref for ServiceConfigurationChangeRequest {
	type Target = crate::v2_5::types::ServiceConfigurationChangeRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceConfigurationChangeRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceConfigurationChangeRequestMt> for ServiceConfigurationChangeRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceConfigurationChangeRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceConfigurationChangeRequestMt> for ServiceConfigurationChangeRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceConfigurationChangeRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceConfigurationChangeRequestMt> for ServiceConfigurationChangeRequest {
	fn from(p: crate::v2_5::types::ServiceConfigurationChangeRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceConfigurationChangeRequestMt> for ServiceConfigurationChangeRequest {
	fn into(self) -> crate::v2_5::types::ServiceConfigurationChangeRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to the ServiceConfigurationChangeRequest. ServiceConfigurationChangeRequestID represents the transaction ID for the configuration Request. ServiceConfigurationChangeRequestStatus indicates the success/failure of the request.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceConfigurationChangeRequestStatus(
	pub crate::v2_5::types::ServiceConfigurationChangeRequestStatusMt,
);
impl Deref for ServiceConfigurationChangeRequestStatus {
	type Target = crate::v2_5::types::ServiceConfigurationChangeRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceConfigurationChangeRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceConfigurationChangeRequestStatusMt> for ServiceConfigurationChangeRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceConfigurationChangeRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceConfigurationChangeRequestStatusMt> for ServiceConfigurationChangeRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceConfigurationChangeRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceConfigurationChangeRequestStatusMt> for ServiceConfigurationChangeRequestStatus {
	fn from(p: crate::v2_5::types::ServiceConfigurationChangeRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceConfigurationChangeRequestStatusMt> for ServiceConfigurationChangeRequestStatus {
	fn into(self) -> crate::v2_5::types::ServiceConfigurationChangeRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message allows services to specify what service specific configuration values can be manipulated by the operator during planning or operations. This message should only be used to advertise legitimate configurable items for a specific service that does not have a legitimate need to be separately documented in the UCI schema. For instance certain algorithmic parameters may be documented on implementation of a service which may be totally inapplicable to another service of the same type that was designed in a different manner. This message facilitates the creation of a generic configuration display that meets the needs of any type of service for which configurable items exist.  A service should publish this message upon initialization to notify the system of their configurable items.  Otherwise, this message is published on receipt of a ServiceConfigurationParamsDataRequest message.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceConfigurationParams(
	pub crate::v2_5::types::ServiceConfigurationParamsMt,
);
impl Deref for ServiceConfigurationParams {
	type Target = crate::v2_5::types::ServiceConfigurationParamsMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceConfigurationParams {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceConfigurationParamsMt> for ServiceConfigurationParams {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceConfigurationParamsMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceConfigurationParamsMt> for ServiceConfigurationParams {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceConfigurationParamsMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceConfigurationParamsMt> for ServiceConfigurationParams {
	fn from(p: crate::v2_5::types::ServiceConfigurationParamsMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceConfigurationParamsMt> for ServiceConfigurationParams {
	fn into(self) -> crate::v2_5::types::ServiceConfigurationParamsMt {
		self.0
	}
}


#[doc = r#"This message indicates a request to services to provide a list of service specific operator modifiable configuration items.  Admin configurable items that should not be changed by an operator during operations or planning should not be advertised utilizing this message. Services that do advertise configuration items via this message are also responsible for responding to requests to alter these configuration items and storing the change persistently.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceConfigurationParamsDataRequest(
	pub crate::v2_5::types::ServiceConfigurationParamsDataRequestMt,
);
impl Deref for ServiceConfigurationParamsDataRequest {
	type Target = crate::v2_5::types::ServiceConfigurationParamsDataRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceConfigurationParamsDataRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceConfigurationParamsDataRequestMt> for ServiceConfigurationParamsDataRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceConfigurationParamsDataRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceConfigurationParamsDataRequestMt> for ServiceConfigurationParamsDataRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceConfigurationParamsDataRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceConfigurationParamsDataRequestMt> for ServiceConfigurationParamsDataRequest {
	fn from(p: crate::v2_5::types::ServiceConfigurationParamsDataRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceConfigurationParamsDataRequestMt> for ServiceConfigurationParamsDataRequest {
	fn into(self) -> crate::v2_5::types::ServiceConfigurationParamsDataRequestMt {
		self.0
	}
}


#[doc = r#"This message is generated in response to a ServiceConfigurationParamsDataRequest.  It provides the state of the request and allows services to return what configuration values can be manipulated by the operator during operations or planning. This message should only be used to advertise legitimate configurable items for a specific service that does not have a legitimate need to be separately documented in the UCI schema. For instance certain algorithmic parameters may be documented on implementation of a service which may be totally inapplicable to another service of the same type that was designed in a different manner. This message facilitates the creation of a generic configuration display that meets the needs of any type of service for which configurable items exist.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceConfigurationParamsDataRequestStatus(
	pub crate::v2_5::types::ServiceConfigurationParamsDataRequestStatusMt,
);
impl Deref for ServiceConfigurationParamsDataRequestStatus {
	type Target = crate::v2_5::types::ServiceConfigurationParamsDataRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceConfigurationParamsDataRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceConfigurationParamsDataRequestStatusMt> for ServiceConfigurationParamsDataRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceConfigurationParamsDataRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceConfigurationParamsDataRequestStatusMt> for ServiceConfigurationParamsDataRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceConfigurationParamsDataRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceConfigurationParamsDataRequestStatusMt> for ServiceConfigurationParamsDataRequestStatus {
	fn from(p: crate::v2_5::types::ServiceConfigurationParamsDataRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceConfigurationParamsDataRequestStatusMt> for ServiceConfigurationParamsDataRequestStatus {
	fn into(self) -> crate::v2_5::types::ServiceConfigurationParamsDataRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message represents a general report of an error that is of significance to other Systems, Services, etc. in the network.  This message is not intended for remote, centralized error logging; it is meant for "error awareness".UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceErrorReport(
	pub crate::v2_5::types::ServiceErrorReportMt,
);
impl Deref for ServiceErrorReport {
	type Target = crate::v2_5::types::ServiceErrorReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceErrorReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceErrorReportMt> for ServiceErrorReport {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceErrorReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceErrorReportMt> for ServiceErrorReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceErrorReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceErrorReportMt> for ServiceErrorReport {
	fn from(p: crate::v2_5::types::ServiceErrorReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceErrorReportMt> for ServiceErrorReport {
	fn into(self) -> crate::v2_5::types::ServiceErrorReportMt {
		self.0
	}
}


#[doc = r#"This message represents a command to one or more services to begin, terminate, or restart operation. Services respond to this command with ServiceLifecycleCommandStatus.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceLifecycleCommand(
	pub crate::v2_5::types::ServiceLifecycleCommandMt,
);
impl Deref for ServiceLifecycleCommand {
	type Target = crate::v2_5::types::ServiceLifecycleCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceLifecycleCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceLifecycleCommandMt> for ServiceLifecycleCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceLifecycleCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceLifecycleCommandMt> for ServiceLifecycleCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceLifecycleCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceLifecycleCommandMt> for ServiceLifecycleCommand {
	fn from(p: crate::v2_5::types::ServiceLifecycleCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceLifecycleCommandMt> for ServiceLifecycleCommand {
	fn into(self) -> crate::v2_5::types::ServiceLifecycleCommandMt {
		self.0
	}
}


#[doc = r#"This message represents a response to service control messages and indicate the success or failure of the operation requested.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceLifecycleCommandStatus(
	pub crate::v2_5::types::ServiceLifecycleCommandStatusMt,
);
impl Deref for ServiceLifecycleCommandStatus {
	type Target = crate::v2_5::types::ServiceLifecycleCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceLifecycleCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceLifecycleCommandStatusMt> for ServiceLifecycleCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceLifecycleCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceLifecycleCommandStatusMt> for ServiceLifecycleCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceLifecycleCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceLifecycleCommandStatusMt> for ServiceLifecycleCommandStatus {
	fn from(p: crate::v2_5::types::ServiceLifecycleCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceLifecycleCommandStatusMt> for ServiceLifecycleCommandStatus {
	fn into(self) -> crate::v2_5::types::ServiceLifecycleCommandStatusMt {
		self.0
	}
}


#[doc = r#"Sent by a service requesting to be registered for specific mission purposes/functions/mission critical transitions.  Allows a service to announce what functions they provide (what its purposes are) that are not related to a Capability.  For example this could be used for mission processing service orchestration along with a system level orchestrator that understands the system needs in executing specific Mission behaviors.  Allows multiple services to be available (registered) to perform functions that are not typical capabilities such as Mission Planning, Routing, Assessment Models, and Task Allocation.  Then the system level orchestrator can determine which of multiple services available for a specific function should be performing the function based on current and/or specific mission objectives.  The registered/unregistered state of the service could be enforced by the orchestrator via the ServiceSettingsCommand message.  Another example of use is if a service becomes disabled, the service orchestration manager could enable another service for the purpose or several others to provide the purposes of the disabled service.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceRegistrationRequest(
	pub crate::v2_5::types::ServiceRegistrationRequestMt,
);
impl Deref for ServiceRegistrationRequest {
	type Target = crate::v2_5::types::ServiceRegistrationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceRegistrationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceRegistrationRequestMt> for ServiceRegistrationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceRegistrationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceRegistrationRequestMt> for ServiceRegistrationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceRegistrationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceRegistrationRequestMt> for ServiceRegistrationRequest {
	fn from(p: crate::v2_5::types::ServiceRegistrationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceRegistrationRequestMt> for ServiceRegistrationRequest {
	fn into(self) -> crate::v2_5::types::ServiceRegistrationRequestMt {
		self.0
	}
}


#[doc = r#"Status returned to a service requesting registration for specific mission purposes/functions/mission critical transitions.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceRegistrationRequestStatus(
	pub crate::v2_5::types::ServiceRegistrationRequestStatusMt,
);
impl Deref for ServiceRegistrationRequestStatus {
	type Target = crate::v2_5::types::ServiceRegistrationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceRegistrationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceRegistrationRequestStatusMt> for ServiceRegistrationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceRegistrationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceRegistrationRequestStatusMt> for ServiceRegistrationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceRegistrationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceRegistrationRequestStatusMt> for ServiceRegistrationRequestStatus {
	fn from(p: crate::v2_5::types::ServiceRegistrationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceRegistrationRequestStatusMt> for ServiceRegistrationRequestStatus {
	fn into(self) -> crate::v2_5::types::ServiceRegistrationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message commands a Service to update its Settings.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceSettingsCommand(
	pub crate::v2_5::types::ServiceSettingsCommandMt,
);
impl Deref for ServiceSettingsCommand {
	type Target = crate::v2_5::types::ServiceSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceSettingsCommandMt> for ServiceSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceSettingsCommandMt> for ServiceSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceSettingsCommandMt> for ServiceSettingsCommand {
	fn from(p: crate::v2_5::types::ServiceSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceSettingsCommandMt> for ServiceSettingsCommand {
	fn into(self) -> crate::v2_5::types::ServiceSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message provides status to a ServiceSettingsCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceSettingsCommandStatus(
	pub crate::v2_5::types::ServiceSettingsCommandStatusMt,
);
impl Deref for ServiceSettingsCommandStatus {
	type Target = crate::v2_5::types::ServiceSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceSettingsCommandStatusMt> for ServiceSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceSettingsCommandStatusMt> for ServiceSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceSettingsCommandStatusMt> for ServiceSettingsCommandStatus {
	fn from(p: crate::v2_5::types::ServiceSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceSettingsCommandStatusMt> for ServiceSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::ServiceSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status of a service.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceStatus(
	pub crate::v2_5::types::ServiceStatusMt,
);
impl Deref for ServiceStatus {
	type Target = crate::v2_5::types::ServiceStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceStatusMt> for ServiceStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceStatusMt> for ServiceStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceStatusMt> for ServiceStatus {
	fn from(p: crate::v2_5::types::ServiceStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceStatusMt> for ServiceStatus {
	fn into(self) -> crate::v2_5::types::ServiceStatusMt {
		self.0
	}
}


#[doc = r#"This message requests the current status of a service.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceStatusDataRequest(
	pub crate::v2_5::types::ServiceStatusDataRequestMt,
);
impl Deref for ServiceStatusDataRequest {
	type Target = crate::v2_5::types::ServiceStatusDataRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceStatusDataRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceStatusDataRequestMt> for ServiceStatusDataRequest {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceStatusDataRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceStatusDataRequestMt> for ServiceStatusDataRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceStatusDataRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceStatusDataRequestMt> for ServiceStatusDataRequest {
	fn from(p: crate::v2_5::types::ServiceStatusDataRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceStatusDataRequestMt> for ServiceStatusDataRequest {
	fn into(self) -> crate::v2_5::types::ServiceStatusDataRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to a ServiceStatusRequest message.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct ServiceStatusDataRequestStatus(
	pub crate::v2_5::types::ServiceStatusDataRequestStatusMt,
);
impl Deref for ServiceStatusDataRequestStatus {
	type Target = crate::v2_5::types::ServiceStatusDataRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for ServiceStatusDataRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::ServiceStatusDataRequestStatusMt> for ServiceStatusDataRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::ServiceStatusDataRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::ServiceStatusDataRequestStatusMt> for ServiceStatusDataRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::ServiceStatusDataRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::ServiceStatusDataRequestStatusMt> for ServiceStatusDataRequestStatus {
	fn from(p: crate::v2_5::types::ServiceStatusDataRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::ServiceStatusDataRequestStatusMt> for ServiceStatusDataRequestStatus {
	fn into(self) -> crate::v2_5::types::ServiceStatusDataRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message provides Support Capability status for any of the Support Capabilities associated with aperture sharing, the ResourceAllocator, Antenna, and RFDC.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SharedApertureSupportCapabilityStatus(
	pub crate::v2_5::types::SharedApertureSupportCapabilityStatusMt,
);
impl Deref for SharedApertureSupportCapabilityStatus {
	type Target = crate::v2_5::types::SharedApertureSupportCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SharedApertureSupportCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SharedApertureSupportCapabilityStatusMt> for SharedApertureSupportCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SharedApertureSupportCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SharedApertureSupportCapabilityStatusMt> for SharedApertureSupportCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SharedApertureSupportCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SharedApertureSupportCapabilityStatusMt> for SharedApertureSupportCapabilityStatus {
	fn from(p: crate::v2_5::types::SharedApertureSupportCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SharedApertureSupportCapabilityStatusMt> for SharedApertureSupportCapabilityStatus {
	fn into(self) -> crate::v2_5::types::SharedApertureSupportCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to report a set of related Signals detected by a signals intelligence (ESM, ELINT and/or COMINT) Subsystem.  The meaning of "related" is intentionally ambiguous.  They could be related through a single common parent Activity, through their association to an emitter Entity or for other reasons.  For signals intelligence Subsystems, detections can be reported at different levels of abstraction corresponding to the PulseData, SignalReport and/or Entity messages.  Additionally, different C2 use cases can result in one or more of the messages being produced.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SignalReport(
	pub crate::v2_5::types::SignalReportMt,
);
impl Deref for SignalReport {
	type Target = crate::v2_5::types::SignalReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SignalReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SignalReportMt> for SignalReport {
	fn as_ref(&self) -> &crate::v2_5::types::SignalReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SignalReportMt> for SignalReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SignalReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SignalReportMt> for SignalReport {
	fn from(p: crate::v2_5::types::SignalReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SignalReportMt> for SignalReport {
	fn into(self) -> crate::v2_5::types::SignalReportMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the SMTI Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (SMTI_Command) from an Operator or Capability management Service, 3) currently in-work SMTI, 4) SMTI scheduled for the future and 5) SMTI that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single SMTI_Command or other triggering event can result in multiple activities within the SMTI_Activity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SmtiActivity(
	pub crate::v2_5::types::SmtiActivityMt,
);
impl Deref for SmtiActivity {
	type Target = crate::v2_5::types::SmtiActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SmtiActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SmtiActivityMt> for SmtiActivity {
	fn as_ref(&self) -> &crate::v2_5::types::SmtiActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SmtiActivityMt> for SmtiActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SmtiActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SmtiActivityMt> for SmtiActivity {
	fn from(p: crate::v2_5::types::SmtiActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SmtiActivityMt> for SmtiActivity {
	fn into(self) -> crate::v2_5::types::SmtiActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the SMTI (Surface Moving Target Indication) category of UCI Capability.  SMTI detects non-airborne items through active radar search and track.  In UCI, SMTI is defined as not-Air MTI; it includes both ground MTI (GMTI) and maritime MTI (MMTI).  This message "advertises" the mostly static characteristics of a mission-ready SMTI Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SmtiCapability(
	pub crate::v2_5::types::SmtiCapabilityMt,
);
impl Deref for SmtiCapability {
	type Target = crate::v2_5::types::SmtiCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SmtiCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SmtiCapabilityMt> for SmtiCapability {
	fn as_ref(&self) -> &crate::v2_5::types::SmtiCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SmtiCapabilityMt> for SmtiCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SmtiCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SmtiCapabilityMt> for SmtiCapability {
	fn from(p: crate::v2_5::types::SmtiCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SmtiCapabilityMt> for SmtiCapability {
	fn into(self) -> crate::v2_5::types::SmtiCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the SMTI capabilities.   This includes whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SmtiCapabilityStatus(
	pub crate::v2_5::types::SmtiCapabilityStatusMt,
);
impl Deref for SmtiCapabilityStatus {
	type Target = crate::v2_5::types::SmtiCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SmtiCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SmtiCapabilityStatusMt> for SmtiCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SmtiCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SmtiCapabilityStatusMt> for SmtiCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SmtiCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SmtiCapabilityStatusMt> for SmtiCapabilityStatus {
	fn from(p: crate::v2_5::types::SmtiCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SmtiCapabilityStatusMt> for SmtiCapabilityStatus {
	fn into(self) -> crate::v2_5::types::SmtiCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the SMTI (Radar Surface Moving Target Indicator, where "surface" includes ground and maritime backgrounds) form of the general UCI Capability Command.  It is used to manually invoke a SMTI Capability to perform a new SMTI Activity or change an existing interactive SMTI Activity.  It differs from a SMTI Task because it is intended for direct interaction with the host of the Capability, not a planning Service, and therefore is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan.  Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages.  Capability Commands can be used in parallel with Tasks, but are generally deferential to them.  However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SmtiCommand(
	pub crate::v2_5::types::SmtiCommandMt,
);
impl Deref for SmtiCommand {
	type Target = crate::v2_5::types::SmtiCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SmtiCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SmtiCommandMt> for SmtiCommand {
	fn as_ref(&self) -> &crate::v2_5::types::SmtiCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SmtiCommandMt> for SmtiCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SmtiCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SmtiCommandMt> for SmtiCommand {
	fn from(p: crate::v2_5::types::SmtiCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SmtiCommandMt> for SmtiCommand {
	fn into(self) -> crate::v2_5::types::SmtiCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an SMTI_Command.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the SMTI_Activity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SmtiCommandStatus(
	pub crate::v2_5::types::SmtiCommandStatusMt,
);
impl Deref for SmtiCommandStatus {
	type Target = crate::v2_5::types::SmtiCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SmtiCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SmtiCommandStatusMt> for SmtiCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SmtiCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SmtiCommandStatusMt> for SmtiCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SmtiCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SmtiCommandStatusMt> for SmtiCommandStatus {
	fn from(p: crate::v2_5::types::SmtiCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SmtiCommandStatusMt> for SmtiCommandStatus {
	fn into(self) -> crate::v2_5::types::SmtiCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the SMTI Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SmtiSettingsCommand(
	pub crate::v2_5::types::SmtiSettingsCommandMt,
);
impl Deref for SmtiSettingsCommand {
	type Target = crate::v2_5::types::SmtiSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SmtiSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SmtiSettingsCommandMt> for SmtiSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::SmtiSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SmtiSettingsCommandMt> for SmtiSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SmtiSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SmtiSettingsCommandMt> for SmtiSettingsCommand {
	fn from(p: crate::v2_5::types::SmtiSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SmtiSettingsCommandMt> for SmtiSettingsCommand {
	fn into(self) -> crate::v2_5::types::SmtiSettingsCommandMt {
		self.0
	}
}


#[doc = r#"Reports the acknowledgment and/or acceptance of an SMTI settings command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SmtiSettingsCommandStatus(
	pub crate::v2_5::types::SmtiSettingsCommandStatusMt,
);
impl Deref for SmtiSettingsCommandStatus {
	type Target = crate::v2_5::types::SmtiSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SmtiSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SmtiSettingsCommandStatusMt> for SmtiSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SmtiSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SmtiSettingsCommandStatusMt> for SmtiSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SmtiSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SmtiSettingsCommandStatusMt> for SmtiSettingsCommandStatus {
	fn from(p: crate::v2_5::types::SmtiSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SmtiSettingsCommandStatusMt> for SmtiSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::SmtiSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message describes the physical and performance characteristics of a space object.  It's generally intended to describe a type of class of satellite.  Specific instances of a type or class of satellite, including its kinematics, are described in separate SpaceRecord messages which can reference the mostly static characteristics described in this message.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SpaceCharacteristics(
	pub crate::v2_5::types::SpaceCharacteristicsMt,
);
impl Deref for SpaceCharacteristics {
	type Target = crate::v2_5::types::SpaceCharacteristicsMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SpaceCharacteristics {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SpaceCharacteristicsMt> for SpaceCharacteristics {
	fn as_ref(&self) -> &crate::v2_5::types::SpaceCharacteristicsMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SpaceCharacteristicsMt> for SpaceCharacteristics {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SpaceCharacteristicsMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SpaceCharacteristicsMt> for SpaceCharacteristics {
	fn from(p: crate::v2_5::types::SpaceCharacteristicsMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SpaceCharacteristicsMt> for SpaceCharacteristics {
	fn into(self) -> crate::v2_5::types::SpaceCharacteristicsMt {
		self.0
	}
}


#[doc = r#"This message contains a representation of an Space (Satellite/Equipment) Record within an Order of Battle.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SpaceRecord(
	pub crate::v2_5::types::SpaceRecordMt,
);
impl Deref for SpaceRecord {
	type Target = crate::v2_5::types::SpaceRecordMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SpaceRecord {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SpaceRecordMt> for SpaceRecord {
	fn as_ref(&self) -> &crate::v2_5::types::SpaceRecordMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SpaceRecordMt> for SpaceRecord {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SpaceRecordMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SpaceRecordMt> for SpaceRecord {
	fn from(p: crate::v2_5::types::SpaceRecordMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SpaceRecordMt> for SpaceRecord {
	fn into(self) -> crate::v2_5::types::SpaceRecordMt {
		self.0
	}
}


#[doc = r#"This message represents weather as a collection of reports and/or warnings, each associated with a specific space weather event.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SpaceWeather(
	pub crate::v2_5::types::SpaceWeatherMt,
);
impl Deref for SpaceWeather {
	type Target = crate::v2_5::types::SpaceWeatherMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SpaceWeather {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SpaceWeatherMt> for SpaceWeather {
	fn as_ref(&self) -> &crate::v2_5::types::SpaceWeatherMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SpaceWeatherMt> for SpaceWeather {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SpaceWeatherMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SpaceWeatherMt> for SpaceWeather {
	fn from(p: crate::v2_5::types::SpaceWeatherMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SpaceWeatherMt> for SpaceWeather {
	fn into(self) -> crate::v2_5::types::SpaceWeatherMt {
		self.0
	}
}


#[doc = r#"Indicates the RF energy spectral density received by an ESM or other RF sensor or communications subsystem.  In the hierarchy of UCI messages used for reporting received RF energy and signals, this message is between raw IQ data and PulseData.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SpectralDensityReport(
	pub crate::v2_5::types::SpectralDensityReportMt,
);
impl Deref for SpectralDensityReport {
	type Target = crate::v2_5::types::SpectralDensityReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SpectralDensityReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SpectralDensityReportMt> for SpectralDensityReport {
	fn as_ref(&self) -> &crate::v2_5::types::SpectralDensityReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SpectralDensityReportMt> for SpectralDensityReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SpectralDensityReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SpectralDensityReportMt> for SpectralDensityReport {
	fn from(p: crate::v2_5::types::SpectralDensityReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SpectralDensityReportMt> for SpectralDensityReport {
	fn into(self) -> crate::v2_5::types::SpectralDensityReportMt {
		self.0
	}
}


#[doc = r#"This message reports the Carriage Capability status.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StoreCarriageCapabilityStatus(
	pub crate::v2_5::types::StoreCarriageCapabilityStatusMt,
);
impl Deref for StoreCarriageCapabilityStatus {
	type Target = crate::v2_5::types::StoreCarriageCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StoreCarriageCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StoreCarriageCapabilityStatusMt> for StoreCarriageCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::StoreCarriageCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StoreCarriageCapabilityStatusMt> for StoreCarriageCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StoreCarriageCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StoreCarriageCapabilityStatusMt> for StoreCarriageCapabilityStatus {
	fn from(p: crate::v2_5::types::StoreCarriageCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StoreCarriageCapabilityStatusMt> for StoreCarriageCapabilityStatus {
	fn into(self) -> crate::v2_5::types::StoreCarriageCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This represents the different possible loadouts for the aircraft. Each loadout is a valid combination of items that could be installed on the aircraft at the same time.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StoreLoadoutConfiguration(
	pub crate::v2_5::types::StoreLoadoutConfigurationMt,
);
impl Deref for StoreLoadoutConfiguration {
	type Target = crate::v2_5::types::StoreLoadoutConfigurationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StoreLoadoutConfiguration {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StoreLoadoutConfigurationMt> for StoreLoadoutConfiguration {
	fn as_ref(&self) -> &crate::v2_5::types::StoreLoadoutConfigurationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StoreLoadoutConfigurationMt> for StoreLoadoutConfiguration {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StoreLoadoutConfigurationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StoreLoadoutConfigurationMt> for StoreLoadoutConfiguration {
	fn from(p: crate::v2_5::types::StoreLoadoutConfigurationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StoreLoadoutConfigurationMt> for StoreLoadoutConfiguration {
	fn into(self) -> crate::v2_5::types::StoreLoadoutConfigurationMt {
		self.0
	}
}


#[doc = r#"This message commands various operations performed on a weapon store.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StoreManagementCommand(
	pub crate::v2_5::types::StoreManagementCommandMt,
);
impl Deref for StoreManagementCommand {
	type Target = crate::v2_5::types::StoreManagementCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StoreManagementCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StoreManagementCommandMt> for StoreManagementCommand {
	fn as_ref(&self) -> &crate::v2_5::types::StoreManagementCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StoreManagementCommandMt> for StoreManagementCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StoreManagementCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StoreManagementCommandMt> for StoreManagementCommand {
	fn from(p: crate::v2_5::types::StoreManagementCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StoreManagementCommandMt> for StoreManagementCommand {
	fn into(self) -> crate::v2_5::types::StoreManagementCommandMt {
		self.0
	}
}


#[doc = r#"This message reports the receipt, acceptance, or rejection of its corresponding StoreManagementCommand message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StoreManagementCommandStatus(
	pub crate::v2_5::types::StoreManagementCommandStatusMt,
);
impl Deref for StoreManagementCommandStatus {
	type Target = crate::v2_5::types::StoreManagementCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StoreManagementCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StoreManagementCommandStatusMt> for StoreManagementCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::StoreManagementCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StoreManagementCommandStatusMt> for StoreManagementCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StoreManagementCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StoreManagementCommandStatusMt> for StoreManagementCommandStatus {
	fn from(p: crate::v2_5::types::StoreManagementCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StoreManagementCommandStatusMt> for StoreManagementCommandStatus {
	fn into(self) -> crate::v2_5::types::StoreManagementCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message contains the state of various weapon store conditions. This includes the dynamic status of the store management support capability of a System.  A stores management support capability is associated with other primary capabilities that it controls such as Strike capabilities.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StoreManagementReport(
	pub crate::v2_5::types::StoreManagementReportMt,
);
impl Deref for StoreManagementReport {
	type Target = crate::v2_5::types::StoreManagementReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StoreManagementReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StoreManagementReportMt> for StoreManagementReport {
	fn as_ref(&self) -> &crate::v2_5::types::StoreManagementReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StoreManagementReportMt> for StoreManagementReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StoreManagementReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StoreManagementReportMt> for StoreManagementReport {
	fn from(p: crate::v2_5::types::StoreManagementReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StoreManagementReportMt> for StoreManagementReport {
	fn into(self) -> crate::v2_5::types::StoreManagementReportMt {
		self.0
	}
}


#[doc = r#"This message contains store weapon types. It describes the stores management supporting capability of a System.  A stores management support capability is associated with other primary capabilities that it controls such as Strike capabilities.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StoreManagementStatus(
	pub crate::v2_5::types::StoreManagementStatusMt,
);
impl Deref for StoreManagementStatus {
	type Target = crate::v2_5::types::StoreManagementStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StoreManagementStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StoreManagementStatusMt> for StoreManagementStatus {
	fn as_ref(&self) -> &crate::v2_5::types::StoreManagementStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StoreManagementStatusMt> for StoreManagementStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StoreManagementStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StoreManagementStatusMt> for StoreManagementStatus {
	fn from(p: crate::v2_5::types::StoreManagementStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StoreManagementStatusMt> for StoreManagementStatus {
	fn into(self) -> crate::v2_5::types::StoreManagementStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the Strike Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (StrikeCommand) from an Operator or Capability management Service, 3) currently in-work Strike, 4) Strike scheduled for the future and 5) Strike that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single StrikeCommand or other triggering event can result in multiple activities within the StrikeActivity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StrikeActivity(
	pub crate::v2_5::types::StrikeActivityMt,
);
impl Deref for StrikeActivity {
	type Target = crate::v2_5::types::StrikeActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StrikeActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StrikeActivityMt> for StrikeActivity {
	fn as_ref(&self) -> &crate::v2_5::types::StrikeActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StrikeActivityMt> for StrikeActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StrikeActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StrikeActivityMt> for StrikeActivity {
	fn from(p: crate::v2_5::types::StrikeActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StrikeActivityMt> for StrikeActivity {
	fn into(self) -> crate::v2_5::types::StrikeActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the Strike category of UCI Capability.  This message "advertises" the mostly static characteristics of a mission-ready Strike Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StrikeCapability(
	pub crate::v2_5::types::StrikeCapabilityMt,
);
impl Deref for StrikeCapability {
	type Target = crate::v2_5::types::StrikeCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StrikeCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StrikeCapabilityMt> for StrikeCapability {
	fn as_ref(&self) -> &crate::v2_5::types::StrikeCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StrikeCapabilityMt> for StrikeCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StrikeCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StrikeCapabilityMt> for StrikeCapability {
	fn from(p: crate::v2_5::types::StrikeCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StrikeCapabilityMt> for StrikeCapability {
	fn into(self) -> crate::v2_5::types::StrikeCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the availability of weapon capabilities and MDF state and status.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StrikeCapabilityStatus(
	pub crate::v2_5::types::StrikeCapabilityStatusMt,
);
impl Deref for StrikeCapabilityStatus {
	type Target = crate::v2_5::types::StrikeCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StrikeCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StrikeCapabilityStatusMt> for StrikeCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::StrikeCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StrikeCapabilityStatusMt> for StrikeCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StrikeCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StrikeCapabilityStatusMt> for StrikeCapabilityStatus {
	fn from(p: crate::v2_5::types::StrikeCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StrikeCapabilityStatusMt> for StrikeCapabilityStatus {
	fn into(self) -> crate::v2_5::types::StrikeCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the Strike form of the general UCI Capability Command.  It is used to manually invoke a Strike Capability to perform a new Strike Activity or change an existing interactive Strike Activity.  It differs from a Strike Task because it is intended for direct interaction with the host of the Capability, not a planning Service, and therefore is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan.  Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages.  Capability Commands can be used in parallel with Tasks, but are generally deferential to them.  However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StrikeCommand(
	pub crate::v2_5::types::StrikeCommandMt,
);
impl Deref for StrikeCommand {
	type Target = crate::v2_5::types::StrikeCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StrikeCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StrikeCommandMt> for StrikeCommand {
	fn as_ref(&self) -> &crate::v2_5::types::StrikeCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StrikeCommandMt> for StrikeCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StrikeCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StrikeCommandMt> for StrikeCommand {
	fn from(p: crate::v2_5::types::StrikeCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StrikeCommandMt> for StrikeCommand {
	fn into(self) -> crate::v2_5::types::StrikeCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of a StrikeCommand.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the StrikeActivity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StrikeCommandStatus(
	pub crate::v2_5::types::StrikeCommandStatusMt,
);
impl Deref for StrikeCommandStatus {
	type Target = crate::v2_5::types::StrikeCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StrikeCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StrikeCommandStatusMt> for StrikeCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::StrikeCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StrikeCommandStatusMt> for StrikeCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StrikeCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StrikeCommandStatusMt> for StrikeCommandStatus {
	fn from(p: crate::v2_5::types::StrikeCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StrikeCommandStatusMt> for StrikeCommandStatus {
	fn into(self) -> crate::v2_5::types::StrikeCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to request consent to perform a Strike Activity.  Status for this command message is provided via the StrikeConsentRequestStatus message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StrikeConsentRequest(
	pub crate::v2_5::types::StrikeConsentRequestMt,
);
impl Deref for StrikeConsentRequest {
	type Target = crate::v2_5::types::StrikeConsentRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StrikeConsentRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StrikeConsentRequestMt> for StrikeConsentRequest {
	fn as_ref(&self) -> &crate::v2_5::types::StrikeConsentRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StrikeConsentRequestMt> for StrikeConsentRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StrikeConsentRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StrikeConsentRequestMt> for StrikeConsentRequest {
	fn from(p: crate::v2_5::types::StrikeConsentRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StrikeConsentRequestMt> for StrikeConsentRequest {
	fn into(self) -> crate::v2_5::types::StrikeConsentRequestMt {
		self.0
	}
}


#[doc = r#"This message reports the receipt, acceptance, or rejection of its corresponding StrikeConsentRequest, which requests consent to perform a Strike Activity.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StrikeConsentRequestStatus(
	pub crate::v2_5::types::StrikeConsentRequestStatusMt,
);
impl Deref for StrikeConsentRequestStatus {
	type Target = crate::v2_5::types::StrikeConsentRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StrikeConsentRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StrikeConsentRequestStatusMt> for StrikeConsentRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::StrikeConsentRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StrikeConsentRequestStatusMt> for StrikeConsentRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StrikeConsentRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StrikeConsentRequestStatusMt> for StrikeConsentRequestStatus {
	fn from(p: crate::v2_5::types::StrikeConsentRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StrikeConsentRequestStatusMt> for StrikeConsentRequestStatus {
	fn into(self) -> crate::v2_5::types::StrikeConsentRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the Strike Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StrikeSettingsCommand(
	pub crate::v2_5::types::StrikeSettingsCommandMt,
);
impl Deref for StrikeSettingsCommand {
	type Target = crate::v2_5::types::StrikeSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StrikeSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StrikeSettingsCommandMt> for StrikeSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::StrikeSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StrikeSettingsCommandMt> for StrikeSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StrikeSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StrikeSettingsCommandMt> for StrikeSettingsCommand {
	fn from(p: crate::v2_5::types::StrikeSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StrikeSettingsCommandMt> for StrikeSettingsCommand {
	fn into(self) -> crate::v2_5::types::StrikeSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message reports the receipt, acceptance, or rejection of its corresponding StrikeSettingsCommand message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct StrikeSettingsCommandStatus(
	pub crate::v2_5::types::StrikeSettingsCommandStatusMt,
);
impl Deref for StrikeSettingsCommandStatus {
	type Target = crate::v2_5::types::StrikeSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for StrikeSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::StrikeSettingsCommandStatusMt> for StrikeSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::StrikeSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::StrikeSettingsCommandStatusMt> for StrikeSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::StrikeSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::StrikeSettingsCommandStatusMt> for StrikeSettingsCommandStatus {
	fn from(p: crate::v2_5::types::StrikeSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::StrikeSettingsCommandStatusMt> for StrikeSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::StrikeSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to command BIT or BIT-related functions.  Some Subsystems only support commanded/initiated BIT via SubsystemStateCommand.  This message is intended for command/initiated BIT that isn't a Subsystem state and generally doesn't interrupt other Subsystem functions.  See SubsystemBIT_Configuration for further details regarding the difference between types of commanded/initiated BIT.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemBitCommand(
	pub crate::v2_5::types::SubsystemBitCommandMt,
);
impl Deref for SubsystemBitCommand {
	type Target = crate::v2_5::types::SubsystemBitCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemBitCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemBitCommandMt> for SubsystemBitCommand {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemBitCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemBitCommandMt> for SubsystemBitCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemBitCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemBitCommandMt> for SubsystemBitCommand {
	fn from(p: crate::v2_5::types::SubsystemBitCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemBitCommandMt> for SubsystemBitCommand {
	fn into(self) -> crate::v2_5::types::SubsystemBitCommandMt {
		self.0
	}
}


#[doc = r#"This message is used to report command status in response to the corresponding SubsystemBIT_Command received by the subsystem.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemBitCommandStatus(
	pub crate::v2_5::types::SubsystemBitCommandStatusMt,
);
impl Deref for SubsystemBitCommandStatus {
	type Target = crate::v2_5::types::SubsystemBitCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemBitCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemBitCommandStatusMt> for SubsystemBitCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemBitCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemBitCommandStatusMt> for SubsystemBitCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemBitCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemBitCommandStatusMt> for SubsystemBitCommandStatus {
	fn from(p: crate::v2_5::types::SubsystemBitCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemBitCommandStatusMt> for SubsystemBitCommandStatus {
	fn into(self) -> crate::v2_5::types::SubsystemBitCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the Built In Test (BIT) messaging interfaces and specific tests supported by a Subsystem.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemBitConfiguration(
	pub crate::v2_5::types::SubsystemBitConfigurationMt,
);
impl Deref for SubsystemBitConfiguration {
	type Target = crate::v2_5::types::SubsystemBitConfigurationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemBitConfiguration {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemBitConfigurationMt> for SubsystemBitConfiguration {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemBitConfigurationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemBitConfigurationMt> for SubsystemBitConfiguration {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemBitConfigurationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemBitConfigurationMt> for SubsystemBitConfiguration {
	fn from(p: crate::v2_5::types::SubsystemBitConfigurationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemBitConfigurationMt> for SubsystemBitConfiguration {
	fn into(self) -> crate::v2_5::types::SubsystemBitConfigurationMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status and results of Subsystem Built In Tests (BIT) along with faults.  This message is used for BIT status regardless of how the BIT is initiated.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemBitStatus(
	pub crate::v2_5::types::SubsystemBitStatusMt,
);
impl Deref for SubsystemBitStatus {
	type Target = crate::v2_5::types::SubsystemBitStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemBitStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemBitStatusMt> for SubsystemBitStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemBitStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemBitStatusMt> for SubsystemBitStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemBitStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemBitStatusMt> for SubsystemBitStatus {
	fn from(p: crate::v2_5::types::SubsystemBitStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemBitStatusMt> for SubsystemBitStatus {
	fn into(self) -> crate::v2_5::types::SubsystemBitStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to command calibration or calibration-related functions.  Some Subsystems only support commanded/initiated calibration via SubsystemStateCommand.  This message is intended for command/initiated Calibration that isn't a Subsystem state and generally doesn't interrupt other Subsystem functions.  See SubsystemCalibrationConfiguration for further details regarding the difference between types of commanded/initiated Calibration.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemCalibrationCommand(
	pub crate::v2_5::types::SubsystemCalibrationCommandMt,
);
impl Deref for SubsystemCalibrationCommand {
	type Target = crate::v2_5::types::SubsystemCalibrationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemCalibrationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemCalibrationCommandMt> for SubsystemCalibrationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemCalibrationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemCalibrationCommandMt> for SubsystemCalibrationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemCalibrationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemCalibrationCommandMt> for SubsystemCalibrationCommand {
	fn from(p: crate::v2_5::types::SubsystemCalibrationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemCalibrationCommandMt> for SubsystemCalibrationCommand {
	fn into(self) -> crate::v2_5::types::SubsystemCalibrationCommandMt {
		self.0
	}
}


#[doc = r#"This message is used to report command status in response to the corresponding SubsystemCalibrationCommand received by the subsystem.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemCalibrationCommandStatus(
	pub crate::v2_5::types::SubsystemCalibrationCommandStatusMt,
);
impl Deref for SubsystemCalibrationCommandStatus {
	type Target = crate::v2_5::types::SubsystemCalibrationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemCalibrationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemCalibrationCommandStatusMt> for SubsystemCalibrationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemCalibrationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemCalibrationCommandStatusMt> for SubsystemCalibrationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemCalibrationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemCalibrationCommandStatusMt> for SubsystemCalibrationCommandStatus {
	fn from(p: crate::v2_5::types::SubsystemCalibrationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemCalibrationCommandStatusMt> for SubsystemCalibrationCommandStatus {
	fn into(self) -> crate::v2_5::types::SubsystemCalibrationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the Calibration messaging interfaces and specific calibrations supported by a Subsystem.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemCalibrationConfiguration(
	pub crate::v2_5::types::SubsystemCalibrationConfigurationMt,
);
impl Deref for SubsystemCalibrationConfiguration {
	type Target = crate::v2_5::types::SubsystemCalibrationConfigurationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemCalibrationConfiguration {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemCalibrationConfigurationMt> for SubsystemCalibrationConfiguration {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemCalibrationConfigurationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemCalibrationConfigurationMt> for SubsystemCalibrationConfiguration {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemCalibrationConfigurationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemCalibrationConfigurationMt> for SubsystemCalibrationConfiguration {
	fn from(p: crate::v2_5::types::SubsystemCalibrationConfigurationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemCalibrationConfigurationMt> for SubsystemCalibrationConfiguration {
	fn into(self) -> crate::v2_5::types::SubsystemCalibrationConfigurationMt {
		self.0
	}
}


#[doc = r#"This message indicates the current status and results of Subsystem Calibration.  This message is used for Calibration status regardless of how the Calibration is initiated.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemCalibrationStatus(
	pub crate::v2_5::types::SubsystemCalibrationStatusMt,
);
impl Deref for SubsystemCalibrationStatus {
	type Target = crate::v2_5::types::SubsystemCalibrationStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemCalibrationStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemCalibrationStatusMt> for SubsystemCalibrationStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemCalibrationStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemCalibrationStatusMt> for SubsystemCalibrationStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemCalibrationStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemCalibrationStatusMt> for SubsystemCalibrationStatus {
	fn from(p: crate::v2_5::types::SubsystemCalibrationStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemCalibrationStatusMt> for SubsystemCalibrationStatus {
	fn into(self) -> crate::v2_5::types::SubsystemCalibrationStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates a Subsystem's current operating configuration.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemConfiguration(
	pub crate::v2_5::types::SubsystemConfigurationMt,
);
impl Deref for SubsystemConfiguration {
	type Target = crate::v2_5::types::SubsystemConfigurationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemConfiguration {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemConfigurationMt> for SubsystemConfiguration {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemConfigurationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemConfigurationMt> for SubsystemConfiguration {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemConfigurationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemConfigurationMt> for SubsystemConfiguration {
	fn from(p: crate::v2_5::types::SubsystemConfigurationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemConfigurationMt> for SubsystemConfiguration {
	fn into(self) -> crate::v2_5::types::SubsystemConfigurationMt {
		self.0
	}
}


#[doc = r#"This message is for requesting a Subsystem's current operating configuration.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemConfigurationDataRequest(
	pub crate::v2_5::types::SubsystemConfigurationDataRequestMt,
);
impl Deref for SubsystemConfigurationDataRequest {
	type Target = crate::v2_5::types::SubsystemConfigurationDataRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemConfigurationDataRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemConfigurationDataRequestMt> for SubsystemConfigurationDataRequest {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemConfigurationDataRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemConfigurationDataRequestMt> for SubsystemConfigurationDataRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemConfigurationDataRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemConfigurationDataRequestMt> for SubsystemConfigurationDataRequest {
	fn from(p: crate::v2_5::types::SubsystemConfigurationDataRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemConfigurationDataRequestMt> for SubsystemConfigurationDataRequest {
	fn into(self) -> crate::v2_5::types::SubsystemConfigurationDataRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to a SubsystemConfigurationRequest message.  Indicates a Subsystem's current operating configuration.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemConfigurationDataRequestStatus(
	pub crate::v2_5::types::SubsystemConfigurationDataRequestStatusMt,
);
impl Deref for SubsystemConfigurationDataRequestStatus {
	type Target = crate::v2_5::types::SubsystemConfigurationDataRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemConfigurationDataRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemConfigurationDataRequestStatusMt> for SubsystemConfigurationDataRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemConfigurationDataRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemConfigurationDataRequestStatusMt> for SubsystemConfigurationDataRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemConfigurationDataRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemConfigurationDataRequestStatusMt> for SubsystemConfigurationDataRequestStatus {
	fn from(p: crate::v2_5::types::SubsystemConfigurationDataRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemConfigurationDataRequestStatusMt> for SubsystemConfigurationDataRequestStatus {
	fn into(self) -> crate::v2_5::types::SubsystemConfigurationDataRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message commands a Subsystem to erase data from memory.  This command should only be used for Subsystems that can perform erase processing independent of Shutdown processing.  The Subsystem remains in one of its Operational states during its erase processing.  If the Subsystem can only perform erase processing during its transition to its terminal SHUTDOWN state, then use the SubsystemStateCommand with CommandState = SHUTDOWN and optional EraseParameter field to include erase processing while shutting down.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemEraseCommand(
	pub crate::v2_5::types::SubsystemEraseCommandMt,
);
impl Deref for SubsystemEraseCommand {
	type Target = crate::v2_5::types::SubsystemEraseCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemEraseCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemEraseCommandMt> for SubsystemEraseCommand {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemEraseCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemEraseCommandMt> for SubsystemEraseCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemEraseCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemEraseCommandMt> for SubsystemEraseCommand {
	fn from(p: crate::v2_5::types::SubsystemEraseCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemEraseCommandMt> for SubsystemEraseCommand {
	fn into(self) -> crate::v2_5::types::SubsystemEraseCommandMt {
		self.0
	}
}


#[doc = r#"This message provides status to a SubsystemEraseCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemEraseCommandStatus(
	pub crate::v2_5::types::SubsystemEraseCommandStatusMt,
);
impl Deref for SubsystemEraseCommandStatus {
	type Target = crate::v2_5::types::SubsystemEraseCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemEraseCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemEraseCommandStatusMt> for SubsystemEraseCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemEraseCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemEraseCommandStatusMt> for SubsystemEraseCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemEraseCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemEraseCommandStatusMt> for SubsystemEraseCommandStatus {
	fn from(p: crate::v2_5::types::SubsystemEraseCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemEraseCommandStatusMt> for SubsystemEraseCommandStatus {
	fn into(self) -> crate::v2_5::types::SubsystemEraseCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message commands a subsystem to perform maintenance test.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemMaintenanceCommand(
	pub crate::v2_5::types::SubsystemMaintenanceCommandMt,
);
impl Deref for SubsystemMaintenanceCommand {
	type Target = crate::v2_5::types::SubsystemMaintenanceCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemMaintenanceCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemMaintenanceCommandMt> for SubsystemMaintenanceCommand {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemMaintenanceCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemMaintenanceCommandMt> for SubsystemMaintenanceCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemMaintenanceCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemMaintenanceCommandMt> for SubsystemMaintenanceCommand {
	fn from(p: crate::v2_5::types::SubsystemMaintenanceCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemMaintenanceCommandMt> for SubsystemMaintenanceCommand {
	fn into(self) -> crate::v2_5::types::SubsystemMaintenanceCommandMt {
		self.0
	}
}


#[doc = r#"This message contains the processing status of the SubsystemMaintenanceCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemMaintenanceCommandStatus(
	pub crate::v2_5::types::SubsystemMaintenanceCommandStatusMt,
);
impl Deref for SubsystemMaintenanceCommandStatus {
	type Target = crate::v2_5::types::SubsystemMaintenanceCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemMaintenanceCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemMaintenanceCommandStatusMt> for SubsystemMaintenanceCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemMaintenanceCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemMaintenanceCommandStatusMt> for SubsystemMaintenanceCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemMaintenanceCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemMaintenanceCommandStatusMt> for SubsystemMaintenanceCommandStatus {
	fn from(p: crate::v2_5::types::SubsystemMaintenanceCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemMaintenanceCommandStatusMt> for SubsystemMaintenanceCommandStatus {
	fn into(self) -> crate::v2_5::types::SubsystemMaintenanceCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the maintenance test messaging interfaces and specific tests supported by a Subsystem. These maintenance tests fall outside standard BIT or calibration tests.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemMaintenanceConfiguration(
	pub crate::v2_5::types::SubsystemMaintenanceConfigurationMt,
);
impl Deref for SubsystemMaintenanceConfiguration {
	type Target = crate::v2_5::types::SubsystemMaintenanceConfigurationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemMaintenanceConfiguration {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemMaintenanceConfigurationMt> for SubsystemMaintenanceConfiguration {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemMaintenanceConfigurationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemMaintenanceConfigurationMt> for SubsystemMaintenanceConfiguration {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemMaintenanceConfigurationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemMaintenanceConfigurationMt> for SubsystemMaintenanceConfiguration {
	fn from(p: crate::v2_5::types::SubsystemMaintenanceConfigurationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemMaintenanceConfigurationMt> for SubsystemMaintenanceConfiguration {
	fn into(self) -> crate::v2_5::types::SubsystemMaintenanceConfigurationMt {
		self.0
	}
}


#[doc = r#"This message contains maintenance operation status. It typically reports all maintenance status unless the MaintenanceCommandInformation is provided for a specific CommandID and its associated tests.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemMaintenanceStatus(
	pub crate::v2_5::types::SubsystemMaintenanceStatusMt,
);
impl Deref for SubsystemMaintenanceStatus {
	type Target = crate::v2_5::types::SubsystemMaintenanceStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemMaintenanceStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemMaintenanceStatusMt> for SubsystemMaintenanceStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemMaintenanceStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemMaintenanceStatusMt> for SubsystemMaintenanceStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemMaintenanceStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemMaintenanceStatusMt> for SubsystemMaintenanceStatus {
	fn from(p: crate::v2_5::types::SubsystemMaintenanceStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemMaintenanceStatusMt> for SubsystemMaintenanceStatus {
	fn into(self) -> crate::v2_5::types::SubsystemMaintenanceStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to command various subsystem settings to be enabled, disabled, or reset, including data recording.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemSettingsCommand(
	pub crate::v2_5::types::SubsystemSettingsCommandMt,
);
impl Deref for SubsystemSettingsCommand {
	type Target = crate::v2_5::types::SubsystemSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemSettingsCommandMt> for SubsystemSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemSettingsCommandMt> for SubsystemSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemSettingsCommandMt> for SubsystemSettingsCommand {
	fn from(p: crate::v2_5::types::SubsystemSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemSettingsCommandMt> for SubsystemSettingsCommand {
	fn into(self) -> crate::v2_5::types::SubsystemSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message is used to report command status in response to the corresponding SubsystemSettingsCommand received by the subsystem.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemSettingsCommandStatus(
	pub crate::v2_5::types::SubsystemSettingsCommandStatusMt,
);
impl Deref for SubsystemSettingsCommandStatus {
	type Target = crate::v2_5::types::SubsystemSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemSettingsCommandStatusMt> for SubsystemSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemSettingsCommandStatusMt> for SubsystemSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemSettingsCommandStatusMt> for SubsystemSettingsCommandStatus {
	fn from(p: crate::v2_5::types::SubsystemSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemSettingsCommandStatusMt> for SubsystemSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::SubsystemSettingsCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to command a subsystem to transition to another of its states if the subsystem is currently in a state to support transition to the commanded state.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemStateCommand(
	pub crate::v2_5::types::SubsystemStateCommandMt,
);
impl Deref for SubsystemStateCommand {
	type Target = crate::v2_5::types::SubsystemStateCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemStateCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemStateCommandMt> for SubsystemStateCommand {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemStateCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemStateCommandMt> for SubsystemStateCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemStateCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemStateCommandMt> for SubsystemStateCommand {
	fn from(p: crate::v2_5::types::SubsystemStateCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemStateCommandMt> for SubsystemStateCommand {
	fn into(self) -> crate::v2_5::types::SubsystemStateCommandMt {
		self.0
	}
}


#[doc = r#"This message is used to report command status in response to the corresponding SubsystemStateCommand received by the subsystem.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemStateCommandStatus(
	pub crate::v2_5::types::SubsystemStateCommandStatusMt,
);
impl Deref for SubsystemStateCommandStatus {
	type Target = crate::v2_5::types::SubsystemStateCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemStateCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemStateCommandStatusMt> for SubsystemStateCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemStateCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemStateCommandStatusMt> for SubsystemStateCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemStateCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemStateCommandStatusMt> for SubsystemStateCommandStatus {
	fn from(p: crate::v2_5::types::SubsystemStateCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemStateCommandStatusMt> for SubsystemStateCommandStatus {
	fn into(self) -> crate::v2_5::types::SubsystemStateCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates a Subsystem's current operating state.  For configuration data use SubsystemConfiguration message.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemStatus(
	pub crate::v2_5::types::SubsystemStatusMt,
);
impl Deref for SubsystemStatus {
	type Target = crate::v2_5::types::SubsystemStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemStatusMt> for SubsystemStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemStatusMt> for SubsystemStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemStatusMt> for SubsystemStatus {
	fn from(p: crate::v2_5::types::SubsystemStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemStatusMt> for SubsystemStatus {
	fn into(self) -> crate::v2_5::types::SubsystemStatusMt {
		self.0
	}
}


#[doc = r#"This message requests the current status of a Subsystem.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemStatusDataRequest(
	pub crate::v2_5::types::SubsystemStatusDataRequestMt,
);
impl Deref for SubsystemStatusDataRequest {
	type Target = crate::v2_5::types::SubsystemStatusDataRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemStatusDataRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemStatusDataRequestMt> for SubsystemStatusDataRequest {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemStatusDataRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemStatusDataRequestMt> for SubsystemStatusDataRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemStatusDataRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemStatusDataRequestMt> for SubsystemStatusDataRequest {
	fn from(p: crate::v2_5::types::SubsystemStatusDataRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemStatusDataRequestMt> for SubsystemStatusDataRequest {
	fn into(self) -> crate::v2_5::types::SubsystemStatusDataRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to a SubsystemStatusRequest message.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemStatusDataRequestStatus(
	pub crate::v2_5::types::SubsystemStatusDataRequestStatusMt,
);
impl Deref for SubsystemStatusDataRequestStatus {
	type Target = crate::v2_5::types::SubsystemStatusDataRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemStatusDataRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemStatusDataRequestStatusMt> for SubsystemStatusDataRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemStatusDataRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemStatusDataRequestStatusMt> for SubsystemStatusDataRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemStatusDataRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemStatusDataRequestStatusMt> for SubsystemStatusDataRequestStatus {
	fn from(p: crate::v2_5::types::SubsystemStatusDataRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemStatusDataRequestStatusMt> for SubsystemStatusDataRequestStatus {
	fn into(self) -> crate::v2_5::types::SubsystemStatusDataRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message contains the current detailed status of the reporting Subsystem.  This message is for reporting subsystem unique data that cannot be reported with other messages.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemStatusDetailed(
	pub crate::v2_5::types::SubsystemStatusDetailedMt,
);
impl Deref for SubsystemStatusDetailed {
	type Target = crate::v2_5::types::SubsystemStatusDetailedMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemStatusDetailed {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemStatusDetailedMt> for SubsystemStatusDetailed {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemStatusDetailedMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemStatusDetailedMt> for SubsystemStatusDetailed {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemStatusDetailedMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemStatusDetailedMt> for SubsystemStatusDetailed {
	fn from(p: crate::v2_5::types::SubsystemStatusDetailedMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemStatusDetailedMt> for SubsystemStatusDetailed {
	fn into(self) -> crate::v2_5::types::SubsystemStatusDetailedMt {
		self.0
	}
}


#[doc = r#"This message is used to request that a Subsystem report its detailed status. A Subsystem will send the SubsystemStatusDetailedRequestStatusMT message when responding to this request.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemStatusDetailedDataRequest(
	pub crate::v2_5::types::SubsystemStatusDetailedDataRequestMt,
);
impl Deref for SubsystemStatusDetailedDataRequest {
	type Target = crate::v2_5::types::SubsystemStatusDetailedDataRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemStatusDetailedDataRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemStatusDetailedDataRequestMt> for SubsystemStatusDetailedDataRequest {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemStatusDetailedDataRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemStatusDetailedDataRequestMt> for SubsystemStatusDetailedDataRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemStatusDetailedDataRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemStatusDetailedDataRequestMt> for SubsystemStatusDetailedDataRequest {
	fn from(p: crate::v2_5::types::SubsystemStatusDetailedDataRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemStatusDetailedDataRequestMt> for SubsystemStatusDetailedDataRequest {
	fn into(self) -> crate::v2_5::types::SubsystemStatusDetailedDataRequestMt {
		self.0
	}
}


#[doc = r#"Provides the status resulting from the handling of a previously received SubsystemStatusDetailedRequest.UCI_PRIMITIVE: DataRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemStatusDetailedDataRequestStatus(
	pub crate::v2_5::types::SubsystemStatusDetailedDataRequestStatusMt,
);
impl Deref for SubsystemStatusDetailedDataRequestStatus {
	type Target = crate::v2_5::types::SubsystemStatusDetailedDataRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemStatusDetailedDataRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemStatusDetailedDataRequestStatusMt> for SubsystemStatusDetailedDataRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemStatusDetailedDataRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemStatusDetailedDataRequestStatusMt> for SubsystemStatusDetailedDataRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemStatusDetailedDataRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemStatusDetailedDataRequestStatusMt> for SubsystemStatusDetailedDataRequestStatus {
	fn from(p: crate::v2_5::types::SubsystemStatusDetailedDataRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemStatusDetailedDataRequestStatusMt> for SubsystemStatusDetailedDataRequestStatus {
	fn into(self) -> crate::v2_5::types::SubsystemStatusDetailedDataRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is a free form text stream associated with a setting of a Subsystem.  This message should not, under any circumstances, be used for C2 purposes or reporting of results of UCI C2 such as Task results, Command results, Service request results, etc.  This message should only be used for reporting of Subsystem-unique data that can't be reasonably standardized and/or is temporary for development purposes.  Examples include debug data, logs, etc. that are needed in real time and therefore can't simply be recorded through file I/O into a Subsystem-unique data file for post-mission use.  The stream is expected to be displayed, sent through an instrumentation link and/or centrally recorded along with other message traffic.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SubsystemStream(
	pub crate::v2_5::types::SubsystemStreamMt,
);
impl Deref for SubsystemStream {
	type Target = crate::v2_5::types::SubsystemStreamMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SubsystemStream {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SubsystemStreamMt> for SubsystemStream {
	fn as_ref(&self) -> &crate::v2_5::types::SubsystemStreamMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SubsystemStreamMt> for SubsystemStream {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SubsystemStreamMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SubsystemStreamMt> for SubsystemStream {
	fn from(p: crate::v2_5::types::SubsystemStreamMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SubsystemStreamMt> for SubsystemStream {
	fn into(self) -> crate::v2_5::types::SubsystemStreamMt {
		self.0
	}
}


#[doc = r#"This message is a request for operations related to suppport such as activation of a SupportPlan or approval of execution of a planned support Requirement.  See the underlying request types for further details.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SupportManagementRequest(
	pub crate::v2_5::types::SupportManagementRequestMt,
);
impl Deref for SupportManagementRequest {
	type Target = crate::v2_5::types::SupportManagementRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SupportManagementRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SupportManagementRequestMt> for SupportManagementRequest {
	fn as_ref(&self) -> &crate::v2_5::types::SupportManagementRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SupportManagementRequestMt> for SupportManagementRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SupportManagementRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SupportManagementRequestMt> for SupportManagementRequest {
	fn from(p: crate::v2_5::types::SupportManagementRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SupportManagementRequestMt> for SupportManagementRequest {
	fn into(self) -> crate::v2_5::types::SupportManagementRequestMt {
		self.0
	}
}


#[doc = r#"This message is status for a SupportManagementRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SupportManagementRequestStatus(
	pub crate::v2_5::types::SupportManagementRequestStatusMt,
);
impl Deref for SupportManagementRequestStatus {
	type Target = crate::v2_5::types::SupportManagementRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SupportManagementRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SupportManagementRequestStatusMt> for SupportManagementRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SupportManagementRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SupportManagementRequestStatusMt> for SupportManagementRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SupportManagementRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SupportManagementRequestStatusMt> for SupportManagementRequestStatus {
	fn from(p: crate::v2_5::types::SupportManagementRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SupportManagementRequestStatusMt> for SupportManagementRequestStatus {
	fn into(self) -> crate::v2_5::types::SupportManagementRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies a set of Requirements that a supporting System has planned in support of another System.  It is intended for peer-to-peer (P2P) C2 use cases where the peers are under different C2 authorities, hierarchies, domains, combatant commands, military services, etc.  It is also intended for use cases where the peers have different opsec, security or classification levels for their operations.

This message enables a supporting System to communicate planned support to a peer System without the full details and complexity from  "primary" *Plan messages such as TaskPlan, RoutePlan and RouteActivityPlan.  Using the SupportPlan message, the P2P C2 process flow between Systems can be decoupled from their primary C2 process flows.  With planned support described in this message, the peer Systems can churn with multiple primary planning iterations (resulting in other *Plan types) without changing the previously coordinated support in the SupportPlan.  A previously coordinated SupportPlan can even be used as a constraint on the primary C2 process flow in the peer Systems. 

The supporting System's primary *Plan messages can include the superset of all Requirements from the primary C2 authority plus multiple supported Systems.  The primary *Plan messages can have full details at the System's highest classification level.  The supporting System's SupportPlan message can include the subset of Requirements that are applicable to a given supported System. 

For example, consider an air domain System at one classification level requesting support from a space domain System at a different classification level in a different combatant command.  The air domain System can request support, at a common classification level, using  SupportPlanRequest* messages addressed to the space domain System.  The space domain System then integrates the requested support Requirements into its primary *Plans.  The primary *Plans can then be reviewed and approved.  Then the subset of Requirements and details relevant to support of the air domain System can be included in a SupportPlan at the common classification level.  The SupportPlan can then be reviewed, approved and activated by the peers.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SupportPlan(
	pub crate::v2_5::types::SupportPlanMt,
);
impl Deref for SupportPlan {
	type Target = crate::v2_5::types::SupportPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SupportPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SupportPlanMt> for SupportPlan {
	fn as_ref(&self) -> &crate::v2_5::types::SupportPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SupportPlanMt> for SupportPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SupportPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SupportPlanMt> for SupportPlan {
	fn from(p: crate::v2_5::types::SupportPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SupportPlanMt> for SupportPlan {
	fn into(self) -> crate::v2_5::types::SupportPlanMt {
		self.0
	}
}


#[doc = r#"This message indicates the execution status for one or more SupportPlans.  Plan execution begins after successful autonomous plan activation or activation via messages.  This message provides execution status regardless of how execution was initiated.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SupportPlanExecutionStatus(
	pub crate::v2_5::types::SupportPlanExecutionStatusMt,
);
impl Deref for SupportPlanExecutionStatus {
	type Target = crate::v2_5::types::SupportPlanExecutionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SupportPlanExecutionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SupportPlanExecutionStatusMt> for SupportPlanExecutionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SupportPlanExecutionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SupportPlanExecutionStatusMt> for SupportPlanExecutionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SupportPlanExecutionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SupportPlanExecutionStatusMt> for SupportPlanExecutionStatus {
	fn from(p: crate::v2_5::types::SupportPlanExecutionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SupportPlanExecutionStatusMt> for SupportPlanExecutionStatus {
	fn into(self) -> crate::v2_5::types::SupportPlanExecutionStatusMt {
		self.0
	}
}


#[doc = r#"This message is a Planned C2 request for support from an "external" supporting asset.  The supported asset to supporting asset relationship could be any combination of peer-to-peer, cross-domain, cross-C2-hierarchy, cross-combatant command, joint, coalition, cross-classification, etc.

The taxonomy for UCI Support C2 is the same as the UCI taxonomy for Planned C2, Response C2 and Direct C2.  All four use the same set of "verbs" described in the Effect, Action, Task, Response and [Capability]Command messages.

SupportPlanRequests can include up to five kinds of "actors": requesting system, responding system, supported asset, supporting asset and other constraining asset.  See annotations for associated elements for cardinality and details. 

UCI Support C2 includes planned and direct options.  The UCI Support* messages require a supported asset to have minimal apriori knowledge of the supporting asset and vice-versa as compared to UCI MissionPlan* and related messages.  It can be used in a "broadcast" use case where multiple Systems respond to a single SupportPlanRequest.  The SupportPlanRequestStatus message is "double keyed" to enable the broadcast use case.

This message includes many inputs to the support planning process but many others may come from a variety of other messages.  A few examples of the many inputs include:
1. Options for constraining the planning function in a variety of ways using existing Plans of the same type or by other Plan types.  For example, a SupportPlan could be constrained by a previous SupportPlan.
2. Overrides/refinements of constraints on the Requirements it references.
3. "Weightings" that influence the decisions of operators or planning algorithms performing the planning.
4. Temporal and/or kinematic begin and end points.

See annotations for the SupportPlan message for further details.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SupportPlanRequest(
	pub crate::v2_5::types::SupportPlanRequestMt,
);
impl Deref for SupportPlanRequest {
	type Target = crate::v2_5::types::SupportPlanRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SupportPlanRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SupportPlanRequestMt> for SupportPlanRequest {
	fn as_ref(&self) -> &crate::v2_5::types::SupportPlanRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SupportPlanRequestMt> for SupportPlanRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SupportPlanRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SupportPlanRequestMt> for SupportPlanRequest {
	fn from(p: crate::v2_5::types::SupportPlanRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SupportPlanRequestMt> for SupportPlanRequest {
	fn into(self) -> crate::v2_5::types::SupportPlanRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a request for support including the current state in a request state machine; see the SupportPlanRequest message.  Creation/update of a SupportPlan may occur autonomously, without a SupportPlanRequest in which case the current state of the plan could be given in the SupportPlanStatus message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SupportPlanRequestStatus(
	pub crate::v2_5::types::SupportPlanRequestStatusMt,
);
impl Deref for SupportPlanRequestStatus {
	type Target = crate::v2_5::types::SupportPlanRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SupportPlanRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SupportPlanRequestStatusMt> for SupportPlanRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SupportPlanRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SupportPlanRequestStatusMt> for SupportPlanRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SupportPlanRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SupportPlanRequestStatusMt> for SupportPlanRequestStatus {
	fn from(p: crate::v2_5::types::SupportPlanRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SupportPlanRequestStatusMt> for SupportPlanRequestStatus {
	fn into(self) -> crate::v2_5::types::SupportPlanRequestStatusMt {
		self.0
	}
}


#[doc = r#"Indicates the status/state of a SupportPlan.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SupportPlanStatus(
	pub crate::v2_5::types::SupportPlanStatusMt,
);
impl Deref for SupportPlanStatus {
	type Target = crate::v2_5::types::SupportPlanStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SupportPlanStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SupportPlanStatusMt> for SupportPlanStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SupportPlanStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SupportPlanStatusMt> for SupportPlanStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SupportPlanStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SupportPlanStatusMt> for SupportPlanStatus {
	fn from(p: crate::v2_5::types::SupportPlanStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SupportPlanStatusMt> for SupportPlanStatus {
	fn into(self) -> crate::v2_5::types::SupportPlanStatusMt {
		self.0
	}
}


#[doc = r#"This message is a Direct C2 request for support from an "external" supporting asset.  The supported asset to supporting asset relationship could be any combination of peer-to-peer, cross-domain, cross-C2-hierarchy, cross-combatant command, joint, coalition, cross-classification, etc.

The taxonomy for UCI Support C2 is the same as the UCI taxonomy for Planned C2, Response C2 and Direct C2.  All four use the same set of "verbs" described in the Effect, Action, Task, Response and [Capability]Command messages.

SupportRequests include two kinds of "actors": requesting/supported system, responding/supporting system.  See annotations for associated elements for cardinality and details. 

UCI Support C2 includes planned and direct options.  The UCI SupportRequest* messages require a supported asset to have minimal apriori knowledge of the supporting asset and vice-versa as compared to UCI MissionPlan* and related messages.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SupportRequest(
	pub crate::v2_5::types::SupportRequestMt,
);
impl Deref for SupportRequest {
	type Target = crate::v2_5::types::SupportRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SupportRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SupportRequestMt> for SupportRequest {
	fn as_ref(&self) -> &crate::v2_5::types::SupportRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SupportRequestMt> for SupportRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SupportRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SupportRequestMt> for SupportRequest {
	fn from(p: crate::v2_5::types::SupportRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SupportRequestMt> for SupportRequest {
	fn into(self) -> crate::v2_5::types::SupportRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an SupportRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SupportRequestStatus(
	pub crate::v2_5::types::SupportRequestStatusMt,
);
impl Deref for SupportRequestStatus {
	type Target = crate::v2_5::types::SupportRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SupportRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SupportRequestStatusMt> for SupportRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SupportRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SupportRequestStatusMt> for SupportRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SupportRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SupportRequestStatusMt> for SupportRequestStatus {
	fn from(p: crate::v2_5::types::SupportRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SupportRequestStatusMt> for SupportRequestStatus {
	fn into(self) -> crate::v2_5::types::SupportRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to specify the relative survivability risks that a mission planner is permitted per a given priority.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SurvivabilityRiskLevel(
	pub crate::v2_5::types::SurvivabilityRiskLevelMt,
);
impl Deref for SurvivabilityRiskLevel {
	type Target = crate::v2_5::types::SurvivabilityRiskLevelMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SurvivabilityRiskLevel {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SurvivabilityRiskLevelMt> for SurvivabilityRiskLevel {
	fn as_ref(&self) -> &crate::v2_5::types::SurvivabilityRiskLevelMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SurvivabilityRiskLevelMt> for SurvivabilityRiskLevel {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SurvivabilityRiskLevelMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SurvivabilityRiskLevelMt> for SurvivabilityRiskLevel {
	fn from(p: crate::v2_5::types::SurvivabilityRiskLevelMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SurvivabilityRiskLevelMt> for SurvivabilityRiskLevel {
	fn into(self) -> crate::v2_5::types::SurvivabilityRiskLevelMt {
		self.0
	}
}


#[doc = r#"A [Capability]Activity message describes what a Capability is doing.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked; it is generally a complete, coherent snapshot of all Activities of a Subsystem for a Capability category.  However, a SystemDeploymentActivity message is different from other [Capability]Activity messages in that it describes the activities of a carrying system that is capable of deploying other systems that have capabilities of their own.  While these systems are not deployed, they are considered a part of the deploying system.  When the ActivityState is active, it means a system is being deployed by the parent system.  The Kinematics (Planned or Actual) are unique to the SystemDeploymentActivity.  The PlannedKinematics element represents the orbit plan the planning service provided for the deployed system and starts upon deployment.  The ActualKinematics becomes key if it is different from what was planned and could be the result of a replan.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemDeploymentActivity(
	pub crate::v2_5::types::SystemDeploymentActivityMt,
);
impl Deref for SystemDeploymentActivity {
	type Target = crate::v2_5::types::SystemDeploymentActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemDeploymentActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemDeploymentActivityMt> for SystemDeploymentActivity {
	fn as_ref(&self) -> &crate::v2_5::types::SystemDeploymentActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemDeploymentActivityMt> for SystemDeploymentActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemDeploymentActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemDeploymentActivityMt> for SystemDeploymentActivity {
	fn from(p: crate::v2_5::types::SystemDeploymentActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemDeploymentActivityMt> for SystemDeploymentActivity {
	fn into(self) -> crate::v2_5::types::SystemDeploymentActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the SystemDeployment category of UCI Capability.  This message "advertises" the mostly static characteristics of a mission-ready SystemDeployment Capability so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.  The SystemDeploymentCapability is unique from other UCI Capability messages in that it represents the capabilities of a carrying system that can deploy another system.  It describes the kinds of deployment the carrying system is able to perform for deploying another system and the systems it can deploy.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemDeploymentCapability(
	pub crate::v2_5::types::SystemDeploymentCapabilityMt,
);
impl Deref for SystemDeploymentCapability {
	type Target = crate::v2_5::types::SystemDeploymentCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemDeploymentCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemDeploymentCapabilityMt> for SystemDeploymentCapability {
	fn as_ref(&self) -> &crate::v2_5::types::SystemDeploymentCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemDeploymentCapabilityMt> for SystemDeploymentCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemDeploymentCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemDeploymentCapabilityMt> for SystemDeploymentCapability {
	fn from(p: crate::v2_5::types::SystemDeploymentCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemDeploymentCapabilityMt> for SystemDeploymentCapability {
	fn into(self) -> crate::v2_5::types::SystemDeploymentCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the System Deployment capabilities available to the carrying system. This includes information regarding whether or not each capability is currently available based on hardware status, operational states, etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemDeploymentCapabilityStatus(
	pub crate::v2_5::types::SystemDeploymentCapabilityStatusMt,
);
impl Deref for SystemDeploymentCapabilityStatus {
	type Target = crate::v2_5::types::SystemDeploymentCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemDeploymentCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemDeploymentCapabilityStatusMt> for SystemDeploymentCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SystemDeploymentCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemDeploymentCapabilityStatusMt> for SystemDeploymentCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemDeploymentCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemDeploymentCapabilityStatusMt> for SystemDeploymentCapabilityStatus {
	fn from(p: crate::v2_5::types::SystemDeploymentCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemDeploymentCapabilityStatusMt> for SystemDeploymentCapabilityStatus {
	fn into(self) -> crate::v2_5::types::SystemDeploymentCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to invoke generation of estimated system state in terms of position and status.  The request includes which messages the estimator service is expected to produce and at what frequency (periodic or single).  The message also optionally allows the user to specify a mission plan segment as the starting point for the estimation.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemEstimationRequest(
	pub crate::v2_5::types::SystemEstimationRequestMt,
);
impl Deref for SystemEstimationRequest {
	type Target = crate::v2_5::types::SystemEstimationRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemEstimationRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemEstimationRequestMt> for SystemEstimationRequest {
	fn as_ref(&self) -> &crate::v2_5::types::SystemEstimationRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemEstimationRequestMt> for SystemEstimationRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemEstimationRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemEstimationRequestMt> for SystemEstimationRequest {
	fn from(p: crate::v2_5::types::SystemEstimationRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemEstimationRequestMt> for SystemEstimationRequest {
	fn into(self) -> crate::v2_5::types::SystemEstimationRequestMt {
		self.0
	}
}


#[doc = r#"This message represents a response to a request to generate an estimated representation of a system.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemEstimationRequestStatus(
	pub crate::v2_5::types::SystemEstimationRequestStatusMt,
);
impl Deref for SystemEstimationRequestStatus {
	type Target = crate::v2_5::types::SystemEstimationRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemEstimationRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemEstimationRequestStatusMt> for SystemEstimationRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SystemEstimationRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemEstimationRequestStatusMt> for SystemEstimationRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemEstimationRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemEstimationRequestStatusMt> for SystemEstimationRequestStatus {
	fn from(p: crate::v2_5::types::SystemEstimationRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemEstimationRequestStatusMt> for SystemEstimationRequestStatus {
	fn into(self) -> crate::v2_5::types::SystemEstimationRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to request changes to a system's status or configurable settings.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemManagementRequest(
	pub crate::v2_5::types::SystemManagementRequestMt,
);
impl Deref for SystemManagementRequest {
	type Target = crate::v2_5::types::SystemManagementRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemManagementRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemManagementRequestMt> for SystemManagementRequest {
	fn as_ref(&self) -> &crate::v2_5::types::SystemManagementRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemManagementRequestMt> for SystemManagementRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemManagementRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemManagementRequestMt> for SystemManagementRequest {
	fn from(p: crate::v2_5::types::SystemManagementRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemManagementRequestMt> for SystemManagementRequest {
	fn into(self) -> crate::v2_5::types::SystemManagementRequestMt {
		self.0
	}
}


#[doc = r#"This message represents a response to a SystemManagementRequest message.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemManagementRequestStatus(
	pub crate::v2_5::types::SystemManagementRequestStatusMt,
);
impl Deref for SystemManagementRequestStatus {
	type Target = crate::v2_5::types::SystemManagementRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemManagementRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemManagementRequestStatusMt> for SystemManagementRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SystemManagementRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemManagementRequestStatusMt> for SystemManagementRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemManagementRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemManagementRequestStatusMt> for SystemManagementRequestStatus {
	fn from(p: crate::v2_5::types::SystemManagementRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemManagementRequestStatusMt> for SystemManagementRequestStatus {
	fn into(self) -> crate::v2_5::types::SystemManagementRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies supplemental data for Systems.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemMetadata(
	pub crate::v2_5::types::SystemMetadataMt,
);
impl Deref for SystemMetadata {
	type Target = crate::v2_5::types::SystemMetadataMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemMetadata {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemMetadataMt> for SystemMetadata {
	fn as_ref(&self) -> &crate::v2_5::types::SystemMetadataMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemMetadataMt> for SystemMetadata {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemMetadataMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemMetadataMt> for SystemMetadata {
	fn from(p: crate::v2_5::types::SystemMetadataMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemMetadataMt> for SystemMetadata {
	fn into(self) -> crate::v2_5::types::SystemMetadataMt {
		self.0
	}
}


#[doc = r#"This message contains a notification related to a System.  There are endless possible events, states, state changes and behaviors of Systems to monitor/observe.  In lieu of enumerating them all, this message categorizes them into "perspectives" such as kinematics, weather and identity.  The message includes the Subject's ID, the perspective of the Subject, a message associated with the notification, and the parameters from NotificationBaseType. For example, a weather monitoring Service could produce a SystemNotification message advising that a particular System is entering an area with potential weather hazards.  This message optionally references other messages that triggered or are related to the notification.  For example, a SystemNotification with a weather perspective could reference a WeatherDataset message with detailed weather data.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemNotification(
	pub crate::v2_5::types::SystemNotificationMt,
);
impl Deref for SystemNotification {
	type Target = crate::v2_5::types::SystemNotificationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemNotification {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemNotificationMt> for SystemNotification {
	fn as_ref(&self) -> &crate::v2_5::types::SystemNotificationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemNotificationMt> for SystemNotification {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemNotificationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemNotificationMt> for SystemNotification {
	fn from(p: crate::v2_5::types::SystemNotificationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemNotificationMt> for SystemNotification {
	fn into(self) -> crate::v2_5::types::SystemNotificationMt {
		self.0
	}
}


#[doc = r#"This message indicates the current propulsive potential of the System. It is one of the space "station-keeping" series of messages for UCI spacecraft Systems. The space station-keeping series is: SystemOrbitalPositionReport, SystemStatus, SystemOrbitReport, [Capability]Status and [Capability]Activity.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemOrbitReport(
	pub crate::v2_5::types::SystemOrbitReportMt,
);
impl Deref for SystemOrbitReport {
	type Target = crate::v2_5::types::SystemOrbitReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemOrbitReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemOrbitReportMt> for SystemOrbitReport {
	fn as_ref(&self) -> &crate::v2_5::types::SystemOrbitReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemOrbitReportMt> for SystemOrbitReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemOrbitReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemOrbitReportMt> for SystemOrbitReport {
	fn from(p: crate::v2_5::types::SystemOrbitReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemOrbitReportMt> for SystemOrbitReport {
	fn into(self) -> crate::v2_5::types::SystemOrbitReportMt {
		self.0
	}
}


#[doc = r#"This message represents what is commonly referred to as the two line element (TLE) for a System in orbit around Earth.  It describes a satellite's orbit using general perturbations theory (SGP, SGP4, PPT3) and Keplerian elements.  An orbital element set (OES) contains six classical orbital elements and a time element (epoch) which can be converted into position and velocity vectors to generate the geometry and motion of where the satellite is located and where it is going.  An OES is a refined collection of data, continually updated over the life of the satellite.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemOrbitalElementSet(
	pub crate::v2_5::types::SystemOrbitalElementSetMt,
);
impl Deref for SystemOrbitalElementSet {
	type Target = crate::v2_5::types::SystemOrbitalElementSetMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemOrbitalElementSet {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemOrbitalElementSetMt> for SystemOrbitalElementSet {
	fn as_ref(&self) -> &crate::v2_5::types::SystemOrbitalElementSetMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemOrbitalElementSetMt> for SystemOrbitalElementSet {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemOrbitalElementSetMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemOrbitalElementSetMt> for SystemOrbitalElementSet {
	fn from(p: crate::v2_5::types::SystemOrbitalElementSetMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemOrbitalElementSetMt> for SystemOrbitalElementSet {
	fn into(self) -> crate::v2_5::types::SystemOrbitalElementSetMt {
		self.0
	}
}


#[doc = r#"This message requests an orbital element set for a System, applicable for a particular time window.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemOrbitalElementSetRequest(
	pub crate::v2_5::types::SystemOrbitalElementSetRequestMt,
);
impl Deref for SystemOrbitalElementSetRequest {
	type Target = crate::v2_5::types::SystemOrbitalElementSetRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemOrbitalElementSetRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemOrbitalElementSetRequestMt> for SystemOrbitalElementSetRequest {
	fn as_ref(&self) -> &crate::v2_5::types::SystemOrbitalElementSetRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemOrbitalElementSetRequestMt> for SystemOrbitalElementSetRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemOrbitalElementSetRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemOrbitalElementSetRequestMt> for SystemOrbitalElementSetRequest {
	fn from(p: crate::v2_5::types::SystemOrbitalElementSetRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemOrbitalElementSetRequestMt> for SystemOrbitalElementSetRequest {
	fn into(self) -> crate::v2_5::types::SystemOrbitalElementSetRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to an SystemOrbitalElementSetRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemOrbitalElementSetRequestStatus(
	pub crate::v2_5::types::SystemOrbitalElementSetRequestStatusMt,
);
impl Deref for SystemOrbitalElementSetRequestStatus {
	type Target = crate::v2_5::types::SystemOrbitalElementSetRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemOrbitalElementSetRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemOrbitalElementSetRequestStatusMt> for SystemOrbitalElementSetRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SystemOrbitalElementSetRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemOrbitalElementSetRequestStatusMt> for SystemOrbitalElementSetRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemOrbitalElementSetRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemOrbitalElementSetRequestStatusMt> for SystemOrbitalElementSetRequestStatus {
	fn from(p: crate::v2_5::types::SystemOrbitalElementSetRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemOrbitalElementSetRequestStatusMt> for SystemOrbitalElementSetRequestStatus {
	fn into(self) -> crate::v2_5::types::SystemOrbitalElementSetRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message represents ephemeris for a System in the form of a series of predicted or actual positions and velocities of a satellite in an orderly sequence of time points (may be created at fixed or variable time spacing). Optionally includes covariance matrices that contains information about the uncertainties associated with the solution of the element corrections.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemOrbitalEphemeris(
	pub crate::v2_5::types::SystemOrbitalEphemerisMt,
);
impl Deref for SystemOrbitalEphemeris {
	type Target = crate::v2_5::types::SystemOrbitalEphemerisMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemOrbitalEphemeris {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemOrbitalEphemerisMt> for SystemOrbitalEphemeris {
	fn as_ref(&self) -> &crate::v2_5::types::SystemOrbitalEphemerisMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemOrbitalEphemerisMt> for SystemOrbitalEphemeris {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemOrbitalEphemerisMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemOrbitalEphemerisMt> for SystemOrbitalEphemeris {
	fn from(p: crate::v2_5::types::SystemOrbitalEphemerisMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemOrbitalEphemerisMt> for SystemOrbitalEphemeris {
	fn into(self) -> crate::v2_5::types::SystemOrbitalEphemerisMt {
		self.0
	}
}


#[doc = r#"This message requests an ephemeris for an orbiting System.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemOrbitalEphemerisRequest(
	pub crate::v2_5::types::SystemOrbitalEphemerisRequestMt,
);
impl Deref for SystemOrbitalEphemerisRequest {
	type Target = crate::v2_5::types::SystemOrbitalEphemerisRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemOrbitalEphemerisRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemOrbitalEphemerisRequestMt> for SystemOrbitalEphemerisRequest {
	fn as_ref(&self) -> &crate::v2_5::types::SystemOrbitalEphemerisRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemOrbitalEphemerisRequestMt> for SystemOrbitalEphemerisRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemOrbitalEphemerisRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemOrbitalEphemerisRequestMt> for SystemOrbitalEphemerisRequest {
	fn from(p: crate::v2_5::types::SystemOrbitalEphemerisRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemOrbitalEphemerisRequestMt> for SystemOrbitalEphemerisRequest {
	fn into(self) -> crate::v2_5::types::SystemOrbitalEphemerisRequestMt {
		self.0
	}
}


#[doc = r#"This message is the response to a SystemOrbitalEphemerisRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemOrbitalEphemerisRequestStatus(
	pub crate::v2_5::types::SystemOrbitalEphemerisRequestStatusMt,
);
impl Deref for SystemOrbitalEphemerisRequestStatus {
	type Target = crate::v2_5::types::SystemOrbitalEphemerisRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemOrbitalEphemerisRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemOrbitalEphemerisRequestStatusMt> for SystemOrbitalEphemerisRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SystemOrbitalEphemerisRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemOrbitalEphemerisRequestStatusMt> for SystemOrbitalEphemerisRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemOrbitalEphemerisRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemOrbitalEphemerisRequestStatusMt> for SystemOrbitalEphemerisRequestStatus {
	fn from(p: crate::v2_5::types::SystemOrbitalEphemerisRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemOrbitalEphemerisRequestStatusMt> for SystemOrbitalEphemerisRequestStatus {
	fn into(self) -> crate::v2_5::types::SystemOrbitalEphemerisRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message represents orbital kinematics for a System in the form of a single Cartesian state vector of position and velocity that together with its time (epoch) uniquely determine the trajectory of an orbiting body in space. Requires selection of the frame of reference and should, in general, only be propagated using the same model used for the orbit determination.  Optionally includes a covariance matrix that contains information about the uncertainties associated with the solution of the element corrections.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemOrbitalPositionReport(
	pub crate::v2_5::types::SystemOrbitalPositionReportMt,
);
impl Deref for SystemOrbitalPositionReport {
	type Target = crate::v2_5::types::SystemOrbitalPositionReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemOrbitalPositionReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemOrbitalPositionReportMt> for SystemOrbitalPositionReport {
	fn as_ref(&self) -> &crate::v2_5::types::SystemOrbitalPositionReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemOrbitalPositionReportMt> for SystemOrbitalPositionReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemOrbitalPositionReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemOrbitalPositionReportMt> for SystemOrbitalPositionReport {
	fn from(p: crate::v2_5::types::SystemOrbitalPositionReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemOrbitalPositionReportMt> for SystemOrbitalPositionReport {
	fn into(self) -> crate::v2_5::types::SystemOrbitalPositionReportMt {
		self.0
	}
}


#[doc = r#"This message represents a "vector covariance matrix" or VCM which is a specialized state vector, along with extensive propagation parameters, tailored specifically for customers who are using an ASW system to propagate the vector.  A VCM should not be confused with the simpler and more common kinematic variance for position-position or position-velocity.  The VCM has all the additional information needed to correctly propagate the vector using the Special Perturbations Ephemeris Generator in ASW. The VCM includes a covariance matrix that provides the epoch covariance in equinoctial elements and only provides UVW variances. TLE and ephemeris for a System are given in other System* messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemOrbitalVcm(
	pub crate::v2_5::types::SystemOrbitalVcmMt,
);
impl Deref for SystemOrbitalVcm {
	type Target = crate::v2_5::types::SystemOrbitalVcmMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemOrbitalVcm {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemOrbitalVcmMt> for SystemOrbitalVcm {
	fn as_ref(&self) -> &crate::v2_5::types::SystemOrbitalVcmMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemOrbitalVcmMt> for SystemOrbitalVcm {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemOrbitalVcmMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemOrbitalVcmMt> for SystemOrbitalVcm {
	fn from(p: crate::v2_5::types::SystemOrbitalVcmMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemOrbitalVcmMt> for SystemOrbitalVcm {
	fn into(self) -> crate::v2_5::types::SystemOrbitalVcmMt {
		self.0
	}
}


#[doc = r#"This message requests an orbital VCM for a System.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemOrbitalVcmRequest(
	pub crate::v2_5::types::SystemOrbitalVcmRequestMt,
);
impl Deref for SystemOrbitalVcmRequest {
	type Target = crate::v2_5::types::SystemOrbitalVcmRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemOrbitalVcmRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemOrbitalVcmRequestMt> for SystemOrbitalVcmRequest {
	fn as_ref(&self) -> &crate::v2_5::types::SystemOrbitalVcmRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemOrbitalVcmRequestMt> for SystemOrbitalVcmRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemOrbitalVcmRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemOrbitalVcmRequestMt> for SystemOrbitalVcmRequest {
	fn from(p: crate::v2_5::types::SystemOrbitalVcmRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemOrbitalVcmRequestMt> for SystemOrbitalVcmRequest {
	fn into(self) -> crate::v2_5::types::SystemOrbitalVcmRequestMt {
		self.0
	}
}


#[doc = r#"This message represents the status in response to a request for an orbital VCM for a System.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemOrbitalVcmRequestStatus(
	pub crate::v2_5::types::SystemOrbitalVcmRequestStatusMt,
);
impl Deref for SystemOrbitalVcmRequestStatus {
	type Target = crate::v2_5::types::SystemOrbitalVcmRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemOrbitalVcmRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemOrbitalVcmRequestStatusMt> for SystemOrbitalVcmRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SystemOrbitalVcmRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemOrbitalVcmRequestStatusMt> for SystemOrbitalVcmRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemOrbitalVcmRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemOrbitalVcmRequestStatusMt> for SystemOrbitalVcmRequestStatus {
	fn from(p: crate::v2_5::types::SystemOrbitalVcmRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemOrbitalVcmRequestStatusMt> for SystemOrbitalVcmRequestStatus {
	fn into(self) -> crate::v2_5::types::SystemOrbitalVcmRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the future status of a system in terms of its availability/readiness for a mission.  It might be reported by a surrogate if the given system can't report it when needed.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemReadiness(
	pub crate::v2_5::types::SystemReadinessMt,
);
impl Deref for SystemReadiness {
	type Target = crate::v2_5::types::SystemReadinessMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemReadiness {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemReadinessMt> for SystemReadiness {
	fn as_ref(&self) -> &crate::v2_5::types::SystemReadinessMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemReadinessMt> for SystemReadiness {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemReadinessMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemReadinessMt> for SystemReadiness {
	fn from(p: crate::v2_5::types::SystemReadinessMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemReadinessMt> for SystemReadiness {
	fn into(self) -> crate::v2_5::types::SystemReadinessMt {
		self.0
	}
}


#[doc = r#"This message indicates the current, highest level summary status of a System, its identification and an indication of the Services, Subsystems and Capabilities it contains.  A System is anything that can self-report information about itself.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemStatus(
	pub crate::v2_5::types::SystemStatusMt,
);
impl Deref for SystemStatus {
	type Target = crate::v2_5::types::SystemStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemStatusMt> for SystemStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SystemStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemStatusMt> for SystemStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemStatusMt> for SystemStatus {
	fn from(p: crate::v2_5::types::SystemStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemStatusMt> for SystemStatus {
	fn into(self) -> crate::v2_5::types::SystemStatusMt {
		self.0
	}
}


#[doc = r#"This message is not a reference for time synchronization.  It is not an alternative to Network Time Protocol (NTP), GPS 1PPS or other means of time synchronization.  It is a complement.  It is a means of sharing the "system time" at the last time synchronization reference event/strobe.  "System time" is the time on whatever the reference clock for the System.  The reference clock could be a local clock or an external clock.  The reference event/strobe could be a discrete signal such as GPS 1PPS.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemTimeAtReference(
	pub crate::v2_5::types::SystemTimeAtReferenceMt,
);
impl Deref for SystemTimeAtReference {
	type Target = crate::v2_5::types::SystemTimeAtReferenceMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemTimeAtReference {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemTimeAtReferenceMt> for SystemTimeAtReference {
	fn as_ref(&self) -> &crate::v2_5::types::SystemTimeAtReferenceMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemTimeAtReferenceMt> for SystemTimeAtReference {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemTimeAtReferenceMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemTimeAtReferenceMt> for SystemTimeAtReference {
	fn from(p: crate::v2_5::types::SystemTimeAtReferenceMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemTimeAtReferenceMt> for SystemTimeAtReference {
	fn into(self) -> crate::v2_5::types::SystemTimeAtReferenceMt {
		self.0
	}
}


#[doc = r#"This message contains a possible loadout for the system ID or model specified. It indicates the minimum number of systems needed to complete a desired set of tasks.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemsNeededRequest(
	pub crate::v2_5::types::SystemsNeededRequestMt,
);
impl Deref for SystemsNeededRequest {
	type Target = crate::v2_5::types::SystemsNeededRequestMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemsNeededRequest {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemsNeededRequestMt> for SystemsNeededRequest {
	fn as_ref(&self) -> &crate::v2_5::types::SystemsNeededRequestMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemsNeededRequestMt> for SystemsNeededRequest {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemsNeededRequestMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemsNeededRequestMt> for SystemsNeededRequest {
	fn from(p: crate::v2_5::types::SystemsNeededRequestMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemsNeededRequestMt> for SystemsNeededRequest {
	fn into(self) -> crate::v2_5::types::SystemsNeededRequestMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of a SystemsNeededRequest.UCI_PRIMITIVE: ActionRequest-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SystemsNeededRequestStatus(
	pub crate::v2_5::types::SystemsNeededRequestStatusMt,
);
impl Deref for SystemsNeededRequestStatus {
	type Target = crate::v2_5::types::SystemsNeededRequestStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for SystemsNeededRequestStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::SystemsNeededRequestStatusMt> for SystemsNeededRequestStatus {
	fn as_ref(&self) -> &crate::v2_5::types::SystemsNeededRequestStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::SystemsNeededRequestStatusMt> for SystemsNeededRequestStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::SystemsNeededRequestStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::SystemsNeededRequestStatusMt> for SystemsNeededRequestStatus {
	fn from(p: crate::v2_5::types::SystemsNeededRequestStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::SystemsNeededRequestStatusMt> for SystemsNeededRequestStatus {
	fn into(self) -> crate::v2_5::types::SystemsNeededRequestStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the Tactical Order Capability of a System.  A [Capability]Activity message describes what a Capability is actively doing. A [Capability]Capability message describes what a Subsystem is capable of doing if invoked; it is generally a complete, coherent snapshot of all Activities of a Subsystem for a Capability category (ESM, EA, etc.). In UCI terminology, an Activity is the dynamic, per-use status of a Capability. An Activity is an abstraction that includes the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability.  For the space domain, only Operational Level messages are provided.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TacticalOrderActivity(
	pub crate::v2_5::types::TacticalOrderActivityMt,
);
impl Deref for TacticalOrderActivity {
	type Target = crate::v2_5::types::TacticalOrderActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TacticalOrderActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TacticalOrderActivityMt> for TacticalOrderActivity {
	fn as_ref(&self) -> &crate::v2_5::types::TacticalOrderActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TacticalOrderActivityMt> for TacticalOrderActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TacticalOrderActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TacticalOrderActivityMt> for TacticalOrderActivity {
	fn from(p: crate::v2_5::types::TacticalOrderActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TacticalOrderActivityMt> for TacticalOrderActivity {
	fn into(self) -> crate::v2_5::types::TacticalOrderActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the Tactical Order category of UCI Capability.  It "advertises" the mostly static characteristics of a mission-ready Tactical Order Capability so that it can be "discovered" and used. "Discovery" can be a misnomer depending on your perspective. UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities. They don't eliminate the need for future software updates or configuration files. UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission. In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services. A [Capability]Capability message describes what a System is capable of doing if invoked. A [Capability]Activity message describes what a Capability is doing. Capabilities are aligned with end effects of Mission operations and for the Tactical Order Capability, it could be an order to refuel, return to base or similar change.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TacticalOrderCapability(
	pub crate::v2_5::types::TacticalOrderCapabilityMt,
);
impl Deref for TacticalOrderCapability {
	type Target = crate::v2_5::types::TacticalOrderCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TacticalOrderCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TacticalOrderCapabilityMt> for TacticalOrderCapability {
	fn as_ref(&self) -> &crate::v2_5::types::TacticalOrderCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TacticalOrderCapabilityMt> for TacticalOrderCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TacticalOrderCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TacticalOrderCapabilityMt> for TacticalOrderCapability {
	fn from(p: crate::v2_5::types::TacticalOrderCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TacticalOrderCapabilityMt> for TacticalOrderCapability {
	fn into(self) -> crate::v2_5::types::TacticalOrderCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the Tactical Order capabilities of a system. This includes information regarding whether or not each capability is currently available based on hardware status, operational states, etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TacticalOrderCapabilityStatus(
	pub crate::v2_5::types::TacticalOrderCapabilityStatusMt,
);
impl Deref for TacticalOrderCapabilityStatus {
	type Target = crate::v2_5::types::TacticalOrderCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TacticalOrderCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TacticalOrderCapabilityStatusMt> for TacticalOrderCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TacticalOrderCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TacticalOrderCapabilityStatusMt> for TacticalOrderCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TacticalOrderCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TacticalOrderCapabilityStatusMt> for TacticalOrderCapabilityStatus {
	fn from(p: crate::v2_5::types::TacticalOrderCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TacticalOrderCapabilityStatusMt> for TacticalOrderCapabilityStatus {
	fn into(self) -> crate::v2_5::types::TacticalOrderCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"Provides a mechanism to make an association between an item and a tag.   Same design pattern as user defined categories that associate things on the internet.  Allows filtering of files by an operator based on flexible criteria, e.g. I want to see all files of any type that have the tags "Targeting" and "Preplanned".  Allows filtering of files by services based on flexible criteria, e.g. I want to discover all imagery that has the tags "Preplanned" and lacks the tag "Processed".UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TagAssociation(
	pub crate::v2_5::types::TagAssociationMt,
);
impl Deref for TagAssociation {
	type Target = crate::v2_5::types::TagAssociationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TagAssociation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TagAssociationMt> for TagAssociation {
	fn as_ref(&self) -> &crate::v2_5::types::TagAssociationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TagAssociationMt> for TagAssociation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TagAssociationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TagAssociationMt> for TagAssociation {
	fn from(p: crate::v2_5::types::TagAssociationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TagAssociationMt> for TagAssociation {
	fn into(self) -> crate::v2_5::types::TagAssociationMt {
		self.0
	}
}


#[doc = r#"This message specifies a Task that a System will perform against a specific entity or geographical location.  Tasks include flight, collection, strike, electronic attack, directed energy, laser designation, cargo delivery and communication relay.  They are abstracted to a level of C2 and autonomy derived from UCI operational vignettes.  Tasks enable services, operators and other actors to do automated, dynamic, machine-to-machine allocation of Tasks to Systems and subsequent mission planning.  If necessary, authorization of Users to Task Systems can be controlled using the Authorization message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Task(
	pub crate::v2_5::types::TaskMt,
);
impl Deref for Task {
	type Target = crate::v2_5::types::TaskMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Task {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskMt> for Task {
	fn as_ref(&self) -> &crate::v2_5::types::TaskMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskMt> for Task {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskMt> for Task {
	fn from(p: crate::v2_5::types::TaskMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskMt> for Task {
	fn into(self) -> crate::v2_5::types::TaskMt {
		self.0
	}
}


#[doc = r#"This message is a request to cancel a Task which has been allocated and planned.  A planning input such as Effect, Action, Task and DMPI can't easily be canceled or removed from the System due to race conditions between their various users and publishers, inevitability of the associated activity, etc.  Additionally, the operator or service initiating the cancellation might be different than the one that manages RequirementSets and/or issues *PlanCommand, introducing additional race conditions.  In order to avoid race conditions, receive positive feedback on the success of the cancellation and allow canceled messages/objects to remain in the system for historical purposes, an explicit TaskCancelCommand is necessary.  A TaskCancelCommand shall result in the Task being canceled unless execution was already inevitable.  If the Task was inevitable and started executing but can be stopped (such as a long collection Task) it shall cancel as soon as possible.  TaskCancelCommand shall result in managers of RequirementSets to remove the associated Task, thereby removing the Task from the next planning cycle.  Services other than those that manage RequirementSets and execute activities aren't required to handle TaskCancelCommand.  TaskCancelCommand doesn't necessarily trigger a replan (there isn't a corresponding planning trigger), therefore a System could continue to navigate routes related to the canceled Task, even though the Task won't occur.  A subsequent replan could exclude the Task.  Status or feedback for this message is given through TaskCancelCommandStatus but the resulting status of the Task is given through TaskStatus.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskCancelCommand(
	pub crate::v2_5::types::TaskCancelCommandMt,
);
impl Deref for TaskCancelCommand {
	type Target = crate::v2_5::types::TaskCancelCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskCancelCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskCancelCommandMt> for TaskCancelCommand {
	fn as_ref(&self) -> &crate::v2_5::types::TaskCancelCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskCancelCommandMt> for TaskCancelCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskCancelCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskCancelCommandMt> for TaskCancelCommand {
	fn from(p: crate::v2_5::types::TaskCancelCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskCancelCommandMt> for TaskCancelCommand {
	fn into(self) -> crate::v2_5::types::TaskCancelCommandMt {
		self.0
	}
}


#[doc = r#"This message is sent in response to a TaskCancelCommand and indicates if the Task was canceled and if not why it was not canceled.  The resulting status of the Task is reported in TaskStatus.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskCancelCommandStatus(
	pub crate::v2_5::types::TaskCancelCommandStatusMt,
);
impl Deref for TaskCancelCommandStatus {
	type Target = crate::v2_5::types::TaskCancelCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskCancelCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskCancelCommandStatusMt> for TaskCancelCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TaskCancelCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskCancelCommandStatusMt> for TaskCancelCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskCancelCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskCancelCommandStatusMt> for TaskCancelCommandStatus {
	fn from(p: crate::v2_5::types::TaskCancelCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskCancelCommandStatusMt> for TaskCancelCommandStatus {
	fn into(self) -> crate::v2_5::types::TaskCancelCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message is the Task form of the general UCI Capability Command.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskCommand(
	pub crate::v2_5::types::TaskCommandMt,
);
impl Deref for TaskCommand {
	type Target = crate::v2_5::types::TaskCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskCommandMt> for TaskCommand {
	fn as_ref(&self) -> &crate::v2_5::types::TaskCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskCommandMt> for TaskCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskCommandMt> for TaskCommand {
	fn from(p: crate::v2_5::types::TaskCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskCommandMt> for TaskCommand {
	fn into(self) -> crate::v2_5::types::TaskCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of an TaskCommand.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskCommandStatus(
	pub crate::v2_5::types::TaskCommandStatusMt,
);
impl Deref for TaskCommandStatus {
	type Target = crate::v2_5::types::TaskCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskCommandStatusMt> for TaskCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TaskCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskCommandStatusMt> for TaskCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskCommandStatusMt> for TaskCommandStatus {
	fn from(p: crate::v2_5::types::TaskCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskCommandStatusMt> for TaskCommandStatus {
	fn into(self) -> crate::v2_5::types::TaskCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the state of approval for execution of a task. ApprovalPolicy allow an authority to define policies to approve or reject a Task as it enters execution. Approval may or may not be required. If approval is required, there can be multiple approvers. See Approval* messages for additional details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskExecutionApprovalStatus(
	pub crate::v2_5::types::TaskExecutionApprovalStatusMt,
);
impl Deref for TaskExecutionApprovalStatus {
	type Target = crate::v2_5::types::TaskExecutionApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskExecutionApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskExecutionApprovalStatusMt> for TaskExecutionApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TaskExecutionApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskExecutionApprovalStatusMt> for TaskExecutionApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskExecutionApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskExecutionApprovalStatusMt> for TaskExecutionApprovalStatus {
	fn from(p: crate::v2_5::types::TaskExecutionApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskExecutionApprovalStatusMt> for TaskExecutionApprovalStatus {
	fn into(self) -> crate::v2_5::types::TaskExecutionApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message specifies the Tasks allocated to a System.  Allocation can be done manually by operators, by an allocation service or a combination.  This message decouples Task allocation from kinematic, action and other types of planning; Tasks allocations can be created, updated and approved independent of other *Plans.  It enables any type of *Plan to be a constraint on task allocation.

A TaskPlan can be an input and/or output of planning processes.  For example the TaskPlan for the top System in a hierarchical System of System could be an input to a task allocation service that the produces a TaskPlan per subordinate System with their subset of allocated Tasks.

Additional details such as timing, dependencies, decomposition, etc. can be added during the task allocation process and captured in the TaskPlan to supplement the information in the allocated Tasks themselves.

A TaskPlan can be created discretely or as part of a MissionPlan that includes other *Plans.  A TaskPlan can only be activated and executed as part of a MissionPlan.  A MissionPlan can be used to plan the execution order of multiple TaskPlans and *Plans in general.  A TaskPlan can be subject to approval per Approval* messages.  Planning, approval, activation and execution state information for a TaskPlan are given in other TaskPlan* messages.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskPlan(
	pub crate::v2_5::types::TaskPlanMt,
);
impl Deref for TaskPlan {
	type Target = crate::v2_5::types::TaskPlanMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskPlan {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskPlanMt> for TaskPlan {
	fn as_ref(&self) -> &crate::v2_5::types::TaskPlanMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskPlanMt> for TaskPlan {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskPlanMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskPlanMt> for TaskPlan {
	fn from(p: crate::v2_5::types::TaskPlanMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskPlanMt> for TaskPlan {
	fn into(self) -> crate::v2_5::types::TaskPlanMt {
		self.0
	}
}


#[doc = r#"This message indicates status/state of approval for a TaskPlan.  Approval may or may not be required.  ApprovalPolicy aligned with the *Plans and states of planning allow a planning oversight authority to approve or reject plans as they're created or updated.  Approval may or may not be required.  If required, there may be many approvers.  See Approval* messages for additional details.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskPlanApprovalStatus(
	pub crate::v2_5::types::TaskPlanApprovalStatusMt,
);
impl Deref for TaskPlanApprovalStatus {
	type Target = crate::v2_5::types::TaskPlanApprovalStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskPlanApprovalStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskPlanApprovalStatusMt> for TaskPlanApprovalStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TaskPlanApprovalStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskPlanApprovalStatusMt> for TaskPlanApprovalStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskPlanApprovalStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskPlanApprovalStatusMt> for TaskPlanApprovalStatus {
	fn from(p: crate::v2_5::types::TaskPlanApprovalStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskPlanApprovalStatusMt> for TaskPlanApprovalStatus {
	fn into(self) -> crate::v2_5::types::TaskPlanApprovalStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to perform a task allocation plan process or function. The TaskPlan message/object is the output of a task allocation plan process or function.  The TaskPlan output of one task allocation plan process function could be an input to the next function.  UCI enables "discovery" of the task allocation plan process and function of a System via the ControlStatus message. This mechanism for discovery empowers a System performing task allocation planning for subordinate Systems of heterogeneous types and/or service/function/process architecture to selectively use, replace or supplement them.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskPlanCommand(
	pub crate::v2_5::types::TaskPlanCommandMt,
);
impl Deref for TaskPlanCommand {
	type Target = crate::v2_5::types::TaskPlanCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskPlanCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskPlanCommandMt> for TaskPlanCommand {
	fn as_ref(&self) -> &crate::v2_5::types::TaskPlanCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskPlanCommandMt> for TaskPlanCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskPlanCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskPlanCommandMt> for TaskPlanCommand {
	fn from(p: crate::v2_5::types::TaskPlanCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskPlanCommandMt> for TaskPlanCommand {
	fn into(self) -> crate::v2_5::types::TaskPlanCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to create/update a TaskPlan, including the current state in a command and processing state machine; see the TaskPlanCommand message.  Creation/update of a TaskPlan  may occur autonomously, without a TaskPlanCommand in which case the current state of the plan could be given in the TaskPlanStatus message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskPlanCommandStatus(
	pub crate::v2_5::types::TaskPlanCommandStatusMt,
);
impl Deref for TaskPlanCommandStatus {
	type Target = crate::v2_5::types::TaskPlanCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskPlanCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskPlanCommandStatusMt> for TaskPlanCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TaskPlanCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskPlanCommandStatusMt> for TaskPlanCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskPlanCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskPlanCommandStatusMt> for TaskPlanCommandStatus {
	fn from(p: crate::v2_5::types::TaskPlanCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskPlanCommandStatusMt> for TaskPlanCommandStatus {
	fn into(self) -> crate::v2_5::types::TaskPlanCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the execution status for one or more TaskPlans.  Plan execution begins after successful autonomous plan activation or activation via MissionPlanActivation messages.  This message provides execution status regardless of how execution was initiated.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskPlanExecutionStatus(
	pub crate::v2_5::types::TaskPlanExecutionStatusMt,
);
impl Deref for TaskPlanExecutionStatus {
	type Target = crate::v2_5::types::TaskPlanExecutionStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskPlanExecutionStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskPlanExecutionStatusMt> for TaskPlanExecutionStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TaskPlanExecutionStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskPlanExecutionStatusMt> for TaskPlanExecutionStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskPlanExecutionStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskPlanExecutionStatusMt> for TaskPlanExecutionStatus {
	fn from(p: crate::v2_5::types::TaskPlanExecutionStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskPlanExecutionStatusMt> for TaskPlanExecutionStatus {
	fn into(self) -> crate::v2_5::types::TaskPlanExecutionStatusMt {
		self.0
	}
}


#[doc = r#"Indicates the status/state of a TaskPlan.

*Plan related status is given in multiple messages aligned with the different types of Systems and Services that provide the status and the different times it is given.  Those messages are *PlanStatus, *PlanApprovalStatus, MissionPlanActivationStatus, *PlanExecutionStatus; see their annotations for further details.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskPlanStatus(
	pub crate::v2_5::types::TaskPlanStatusMt,
);
impl Deref for TaskPlanStatus {
	type Target = crate::v2_5::types::TaskPlanStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskPlanStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskPlanStatusMt> for TaskPlanStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TaskPlanStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskPlanStatusMt> for TaskPlanStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskPlanStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskPlanStatusMt> for TaskPlanStatus {
	fn from(p: crate::v2_5::types::TaskPlanStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskPlanStatusMt> for TaskPlanStatus {
	fn into(self) -> crate::v2_5::types::TaskPlanStatusMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of the validation, including the current state in a validation state machine, and details of invalid items. Validation may occur periodically, or onesie twosie. See the TaskPlanValidationCommand message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskPlanValidation(
	pub crate::v2_5::types::TaskPlanValidationMt,
);
impl Deref for TaskPlanValidation {
	type Target = crate::v2_5::types::TaskPlanValidationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskPlanValidation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskPlanValidationMt> for TaskPlanValidation {
	fn as_ref(&self) -> &crate::v2_5::types::TaskPlanValidationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskPlanValidationMt> for TaskPlanValidation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskPlanValidationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskPlanValidationMt> for TaskPlanValidation {
	fn from(p: crate::v2_5::types::TaskPlanValidationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskPlanValidationMt> for TaskPlanValidation {
	fn into(self) -> crate::v2_5::types::TaskPlanValidationMt {
		self.0
	}
}


#[doc = r#"This message indicates a command to validate/re-validate an existing TaskPlan.  It includes an option to modify the Plan to make it valid if it is found to be invalid.  A TaskPlan can become invalid due to changes in Task timing, weather, order of battle, kinematic movement constraints, operator manual edits and many, many other reasons.  The message allows an existing TaskPlan to be checked for validity given such changes.  The variables a given planning service, operator or system considers when validating a plan varies.  Different variables might be considered depending on the level of detail of the plan or stage in the overall planning process.  The scope and meaning of "valid" comes from context of the services, operator and systems creating the plan.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskPlanValidationCommand(
	pub crate::v2_5::types::TaskPlanValidationCommandMt,
);
impl Deref for TaskPlanValidationCommand {
	type Target = crate::v2_5::types::TaskPlanValidationCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskPlanValidationCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskPlanValidationCommandMt> for TaskPlanValidationCommand {
	fn as_ref(&self) -> &crate::v2_5::types::TaskPlanValidationCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskPlanValidationCommandMt> for TaskPlanValidationCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskPlanValidationCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskPlanValidationCommandMt> for TaskPlanValidationCommand {
	fn from(p: crate::v2_5::types::TaskPlanValidationCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskPlanValidationCommandMt> for TaskPlanValidationCommand {
	fn into(self) -> crate::v2_5::types::TaskPlanValidationCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the status of a command to validate a TaskPlan, including the current state in a command and processing state machine.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskPlanValidationCommandStatus(
	pub crate::v2_5::types::TaskPlanValidationCommandStatusMt,
);
impl Deref for TaskPlanValidationCommandStatus {
	type Target = crate::v2_5::types::TaskPlanValidationCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskPlanValidationCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskPlanValidationCommandStatusMt> for TaskPlanValidationCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TaskPlanValidationCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskPlanValidationCommandStatusMt> for TaskPlanValidationCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskPlanValidationCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskPlanValidationCommandStatusMt> for TaskPlanValidationCommandStatus {
	fn from(p: crate::v2_5::types::TaskPlanValidationCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskPlanValidationCommandStatusMt> for TaskPlanValidationCommandStatus {
	fn into(self) -> crate::v2_5::types::TaskPlanValidationCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message defines planning status of a single Task.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskPlanningStatus(
	pub crate::v2_5::types::TaskPlanningStatusMt,
);
impl Deref for TaskPlanningStatus {
	type Target = crate::v2_5::types::TaskPlanningStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskPlanningStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskPlanningStatusMt> for TaskPlanningStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TaskPlanningStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskPlanningStatusMt> for TaskPlanningStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskPlanningStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskPlanningStatusMt> for TaskPlanningStatus {
	fn from(p: crate::v2_5::types::TaskPlanningStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskPlanningStatusMt> for TaskPlanningStatus {
	fn into(self) -> crate::v2_5::types::TaskPlanningStatusMt {
		self.0
	}
}


#[doc = r#"Indicates the execution status for a Task.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TaskStatus(
	pub crate::v2_5::types::TaskStatusMt,
);
impl Deref for TaskStatus {
	type Target = crate::v2_5::types::TaskStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TaskStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TaskStatusMt> for TaskStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TaskStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TaskStatusMt> for TaskStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TaskStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TaskStatusMt> for TaskStatus {
	fn from(p: crate::v2_5::types::TaskStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TaskStatusMt> for TaskStatus {
	fn into(self) -> crate::v2_5::types::TaskStatusMt {
		self.0
	}
}


#[doc = r#"This message is used to manually command a turret's mode of operation or to directly tell it where to look.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TurretCommand(
	pub crate::v2_5::types::TurretCommandMt,
);
impl Deref for TurretCommand {
	type Target = crate::v2_5::types::TurretCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TurretCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TurretCommandMt> for TurretCommand {
	fn as_ref(&self) -> &crate::v2_5::types::TurretCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TurretCommandMt> for TurretCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TurretCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TurretCommandMt> for TurretCommand {
	fn from(p: crate::v2_5::types::TurretCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TurretCommandMt> for TurretCommand {
	fn into(self) -> crate::v2_5::types::TurretCommandMt {
		self.0
	}
}


#[doc = r#"This message reports the receipt, acceptance, or rejection of its corresponding TurretCommand message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TurretCommandStatus(
	pub crate::v2_5::types::TurretCommandStatusMt,
);
impl Deref for TurretCommandStatus {
	type Target = crate::v2_5::types::TurretCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TurretCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TurretCommandStatusMt> for TurretCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TurretCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TurretCommandStatusMt> for TurretCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TurretCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TurretCommandStatusMt> for TurretCommandStatus {
	fn from(p: crate::v2_5::types::TurretCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TurretCommandStatusMt> for TurretCommandStatus {
	fn into(self) -> crate::v2_5::types::TurretCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message reports the current operational state of the turret, including where it is pointing.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TurretReport(
	pub crate::v2_5::types::TurretReportMt,
);
impl Deref for TurretReport {
	type Target = crate::v2_5::types::TurretReportMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TurretReport {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TurretReportMt> for TurretReport {
	fn as_ref(&self) -> &crate::v2_5::types::TurretReportMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TurretReportMt> for TurretReport {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TurretReportMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TurretReportMt> for TurretReport {
	fn from(p: crate::v2_5::types::TurretReportMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TurretReportMt> for TurretReport {
	fn into(self) -> crate::v2_5::types::TurretReportMt {
		self.0
	}
}


#[doc = r#"This message contains the current status of a turret, including information regarding whether or not it is currently available to be commanded, based on hardware status, commanded operational states, etc. A turret is a component of the vehicle that provides a gimbal for other components, such as optical sensors (EOIR ball), laser designators, or directed energy weapons.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TurretStatus(
	pub crate::v2_5::types::TurretStatusMt,
);
impl Deref for TurretStatus {
	type Target = crate::v2_5::types::TurretStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for TurretStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::TurretStatusMt> for TurretStatus {
	fn as_ref(&self) -> &crate::v2_5::types::TurretStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::TurretStatusMt> for TurretStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::TurretStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::TurretStatusMt> for TurretStatus {
	fn from(p: crate::v2_5::types::TurretStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::TurretStatusMt> for TurretStatus {
	fn into(self) -> crate::v2_5::types::TurretStatusMt {
		self.0
	}
}


#[doc = r#"This message contains a representation of an Unit Record within an Order of Battle.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct UnitRecord(
	pub crate::v2_5::types::UnitRecordMt,
);
impl Deref for UnitRecord {
	type Target = crate::v2_5::types::UnitRecordMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for UnitRecord {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::UnitRecordMt> for UnitRecord {
	fn as_ref(&self) -> &crate::v2_5::types::UnitRecordMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::UnitRecordMt> for UnitRecord {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::UnitRecordMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::UnitRecordMt> for UnitRecord {
	fn from(p: crate::v2_5::types::UnitRecordMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::UnitRecordMt> for UnitRecord {
	fn into(self) -> crate::v2_5::types::UnitRecordMt {
		self.0
	}
}


#[doc = r#"This message represents weather as a collection of reports and/or warnings, each associated with a geospatial location.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Weather(
	pub crate::v2_5::types::WeatherMt,
);
impl Deref for Weather {
	type Target = crate::v2_5::types::WeatherMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for Weather {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::WeatherMt> for Weather {
	fn as_ref(&self) -> &crate::v2_5::types::WeatherMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::WeatherMt> for Weather {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::WeatherMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::WeatherMt> for Weather {
	fn from(p: crate::v2_5::types::WeatherMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::WeatherMt> for Weather {
	fn into(self) -> crate::v2_5::types::WeatherMt {
		self.0
	}
}


#[doc = r#"This message represents weather summarized from an external source that will be used for planning.UCI_PRIMITIVE: DataRecord-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct WeatherDataset(
	pub crate::v2_5::types::WeatherDatasetMt,
);
impl Deref for WeatherDataset {
	type Target = crate::v2_5::types::WeatherDatasetMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for WeatherDataset {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::WeatherDatasetMt> for WeatherDataset {
	fn as_ref(&self) -> &crate::v2_5::types::WeatherDatasetMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::WeatherDatasetMt> for WeatherDataset {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::WeatherDatasetMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::WeatherDatasetMt> for WeatherDataset {
	fn from(p: crate::v2_5::types::WeatherDatasetMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::WeatherDatasetMt> for WeatherDataset {
	fn into(self) -> crate::v2_5::types::WeatherDatasetMt {
		self.0
	}
}


#[doc = r#"This message represents a weather observation from a System.  WeatherObservations are generally less formal than WeatherReports or WeatherWarnings, originating from Systems whose primary mission isn't weather related.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct WeatherObservation(
	pub crate::v2_5::types::WeatherObservationMt,
);
impl Deref for WeatherObservation {
	type Target = crate::v2_5::types::WeatherObservationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for WeatherObservation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::WeatherObservationMt> for WeatherObservation {
	fn as_ref(&self) -> &crate::v2_5::types::WeatherObservationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::WeatherObservationMt> for WeatherObservation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::WeatherObservationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::WeatherObservationMt> for WeatherObservation {
	fn from(p: crate::v2_5::types::WeatherObservationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::WeatherObservationMt> for WeatherObservation {
	fn into(self) -> crate::v2_5::types::WeatherObservationMt {
		self.0
	}
}


#[doc = r#"This message indicates the combined in-work and to-do list of the WeatherRadar Capability of a Subsystem of a System.  In general, a [Capability]Activity message describes what invoked Capabilities are doing.  It is generally a complete, coherent snapshot of all Activities of a Subsystem for an entire Capability category (such as ESM, AirSample, EA, etc.).  In other words, an Activity is the dynamic, per-use/per-invocation status of a Capability.  An Activity is an abstraction that includes 1) the autonomous (MDF-driven or MissionPlan-driven) activity of a Capability, 2) the activity resulting from manual commands (WeatherRadarCommand) from an Operator or Capability management Service, 3) currently in-work collection, 4) collection scheduled for the future and 5) collection that was scheduled and/or attempted but couldn't be completed due to resource limitations or other reasons.  A single *Command or other triggering event can result in multiple activities within the WeatherRadarActivity message.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct WeatherRadarActivity(
	pub crate::v2_5::types::WeatherRadarActivityMt,
);
impl Deref for WeatherRadarActivity {
	type Target = crate::v2_5::types::WeatherRadarActivityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for WeatherRadarActivity {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::WeatherRadarActivityMt> for WeatherRadarActivity {
	fn as_ref(&self) -> &crate::v2_5::types::WeatherRadarActivityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::WeatherRadarActivityMt> for WeatherRadarActivity {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::WeatherRadarActivityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::WeatherRadarActivityMt> for WeatherRadarActivity {
	fn from(p: crate::v2_5::types::WeatherRadarActivityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::WeatherRadarActivityMt> for WeatherRadarActivity {
	fn into(self) -> crate::v2_5::types::WeatherRadarActivityMt {
		self.0
	}
}


#[doc = r#"This message represents the Weather Radar category of UCI Capability.  This message "advertises" the mostly static characteristics of a mission-ready Weather Radar Capability (of a Subsystem of System) so that it can be "discovered" and used.  "Discovery" can be a misnomer depending on your perspective.  UCI Capability messages aren't meant to enable dynamic discovery of design details of never-before-seen Capabilities.  They don't eliminate the need for future software updates or configuration files with performance characteristics indexed by Subsystem model number.  UCI Capability messages are meant to support discovery of what changes for a Capability from mission to mission or even within the course of a mission, especially as it relates to command and control.  In UCI terminology, a Capability is something a System can do that is useful in Missions performed by a heterogeneous family of Systems and Services.  A [Capability]Capability message describes what a Subsystem is capable of doing if invoked.  A [Capability]Activity message describes what a Capability is doing.  Capabilities are aligned with end effects of Mission operations such as imagery collection, active target search, passive threat detection, electronic attack and others.  Functions which support these end effects including turret control, carriage control and door control aren't considered UCI Capabilities but might be addressed by other UCI messages.  Capabilities are the standardized taxonomy of high level Mission end-effects functions a System can perform.  Further, the Capability taxonomy establishes the "level" at which the Mission Subsystems of a System: 1) can be controlled, 2) can be functionally re-integrated into new Systems without their application software changing, 3) are modeled by allocation and planning services including Task Allocation, Route Planning, Mission Monitoring/Contingency and Task Generation services, 4) are modeled by Capability management services including Capability Managers and Capability Controllers and 5) report their configuration, availability and status.UCI_PRIMITIVE: Data-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct WeatherRadarCapability(
	pub crate::v2_5::types::WeatherRadarCapabilityMt,
);
impl Deref for WeatherRadarCapability {
	type Target = crate::v2_5::types::WeatherRadarCapabilityMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for WeatherRadarCapability {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::WeatherRadarCapabilityMt> for WeatherRadarCapability {
	fn as_ref(&self) -> &crate::v2_5::types::WeatherRadarCapabilityMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::WeatherRadarCapabilityMt> for WeatherRadarCapability {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::WeatherRadarCapabilityMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::WeatherRadarCapabilityMt> for WeatherRadarCapability {
	fn from(p: crate::v2_5::types::WeatherRadarCapabilityMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::WeatherRadarCapabilityMt> for WeatherRadarCapability {
	fn into(self) -> crate::v2_5::types::WeatherRadarCapabilityMt {
		self.0
	}
}


#[doc = r#"This message reports the current status of the WeatherRadar capabilities available to the system.   This includes information regarding whether or not each capability is currently available based on hardware status, commanded operational states, associated RF profiles etc.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct WeatherRadarCapabilityStatus(
	pub crate::v2_5::types::WeatherRadarCapabilityStatusMt,
);
impl Deref for WeatherRadarCapabilityStatus {
	type Target = crate::v2_5::types::WeatherRadarCapabilityStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for WeatherRadarCapabilityStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::WeatherRadarCapabilityStatusMt> for WeatherRadarCapabilityStatus {
	fn as_ref(&self) -> &crate::v2_5::types::WeatherRadarCapabilityStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::WeatherRadarCapabilityStatusMt> for WeatherRadarCapabilityStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::WeatherRadarCapabilityStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::WeatherRadarCapabilityStatusMt> for WeatherRadarCapabilityStatus {
	fn from(p: crate::v2_5::types::WeatherRadarCapabilityStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::WeatherRadarCapabilityStatusMt> for WeatherRadarCapabilityStatus {
	fn into(self) -> crate::v2_5::types::WeatherRadarCapabilityStatusMt {
		self.0
	}
}


#[doc = r#"This message is the Weather Radar form of the general UCI Capability Command.  It is used to manually invoke a Weather Radar Capability to perform a new Weather Radar Activity or change an existing interactive Activity.  It differs from a Weather Radar Task because it is intended for direct interaction with the host of the Capability, not a planning Service, and therefore is not expected to impact the route of the host System or otherwise interrupt the planned MissionPlan.  Additionally, Capability Commands are intended to allow multiple clients to use a single Capability as a shared resource; see the Control* series of messages.  Capability Commands can be used in parallel with Tasks, but are generally deferential to them.  However, exceptions are allowed and even expected; the relationship between Tasks and Capability Commands is not rigidly dictated by the UCI schema.  Several mechanisms are provided in other messages to tailor the relationship and relative importance of Tasks and [Capability]Commands including Capability precedence, Task rank, [Capability]Command rank, [Capability]Activity rank and control Authorization.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct WeatherRadarCommand(
	pub crate::v2_5::types::WeatherRadarCommandMt,
);
impl Deref for WeatherRadarCommand {
	type Target = crate::v2_5::types::WeatherRadarCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for WeatherRadarCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::WeatherRadarCommandMt> for WeatherRadarCommand {
	fn as_ref(&self) -> &crate::v2_5::types::WeatherRadarCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::WeatherRadarCommandMt> for WeatherRadarCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::WeatherRadarCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::WeatherRadarCommandMt> for WeatherRadarCommand {
	fn from(p: crate::v2_5::types::WeatherRadarCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::WeatherRadarCommandMt> for WeatherRadarCommand {
	fn into(self) -> crate::v2_5::types::WeatherRadarCommandMt {
		self.0
	}
}


#[doc = r#"This message indicates the result of a WeatherRadarCommand.  This message will reflect whether the command was received, accepted and/or rejected.  This message will only be used to status the command until the recipient determines whether or not it can be started or scheduled.  The details of the specific activity or activities that result from the command will report status via the WeatherRadarActivity message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct WeatherRadarCommandStatus(
	pub crate::v2_5::types::WeatherRadarCommandStatusMt,
);
impl Deref for WeatherRadarCommandStatus {
	type Target = crate::v2_5::types::WeatherRadarCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for WeatherRadarCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::WeatherRadarCommandStatusMt> for WeatherRadarCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::WeatherRadarCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::WeatherRadarCommandStatusMt> for WeatherRadarCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::WeatherRadarCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::WeatherRadarCommandStatusMt> for WeatherRadarCommandStatus {
	fn from(p: crate::v2_5::types::WeatherRadarCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::WeatherRadarCommandStatusMt> for WeatherRadarCommandStatus {
	fn into(self) -> crate::v2_5::types::WeatherRadarCommandStatusMt {
		self.0
	}
}


#[doc = r#"This message contains weather data as observed by a system at a given location and time.UCI_PRIMITIVE: Status-1."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct WeatherRadarObservation(
	pub crate::v2_5::types::WeatherRadarObservationMt,
);
impl Deref for WeatherRadarObservation {
	type Target = crate::v2_5::types::WeatherRadarObservationMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for WeatherRadarObservation {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::WeatherRadarObservationMt> for WeatherRadarObservation {
	fn as_ref(&self) -> &crate::v2_5::types::WeatherRadarObservationMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::WeatherRadarObservationMt> for WeatherRadarObservation {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::WeatherRadarObservationMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::WeatherRadarObservationMt> for WeatherRadarObservation {
	fn from(p: crate::v2_5::types::WeatherRadarObservationMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::WeatherRadarObservationMt> for WeatherRadarObservation {
	fn into(self) -> crate::v2_5::types::WeatherRadarObservationMt {
		self.0
	}
}


#[doc = r#"This message is used to change the "settings" associated with all of the WeatherRadar Capabilities of a Subsystem.  [Capability]SettingsCommands generally affect the subsequent operation of all applicable Capabilities of the Subsystem; they are considered presettings, independent of [Capability]Command.  Unlike most [Capability]Commands they are understood to remain set until changed.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct WeatherRadarSettingsCommand(
	pub crate::v2_5::types::WeatherRadarSettingsCommandMt,
);
impl Deref for WeatherRadarSettingsCommand {
	type Target = crate::v2_5::types::WeatherRadarSettingsCommandMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for WeatherRadarSettingsCommand {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::WeatherRadarSettingsCommandMt> for WeatherRadarSettingsCommand {
	fn as_ref(&self) -> &crate::v2_5::types::WeatherRadarSettingsCommandMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::WeatherRadarSettingsCommandMt> for WeatherRadarSettingsCommand {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::WeatherRadarSettingsCommandMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::WeatherRadarSettingsCommandMt> for WeatherRadarSettingsCommand {
	fn from(p: crate::v2_5::types::WeatherRadarSettingsCommandMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::WeatherRadarSettingsCommandMt> for WeatherRadarSettingsCommand {
	fn into(self) -> crate::v2_5::types::WeatherRadarSettingsCommandMt {
		self.0
	}
}


#[doc = r#"This message reports the receipt, acceptance, or rejection of its corresponding WeatherRadarSettingsCommand message.UCI_PRIMITIVE: Command-2."#]
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct WeatherRadarSettingsCommandStatus(
	pub crate::v2_5::types::WeatherRadarSettingsCommandStatusMt,
);
impl Deref for WeatherRadarSettingsCommandStatus {
	type Target = crate::v2_5::types::WeatherRadarSettingsCommandStatusMt;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}
impl DerefMut for WeatherRadarSettingsCommandStatus {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}
impl AsRef<crate::v2_5::types::WeatherRadarSettingsCommandStatusMt> for WeatherRadarSettingsCommandStatus {
	fn as_ref(&self) -> &crate::v2_5::types::WeatherRadarSettingsCommandStatusMt {
		&self.0
	}
}
impl AsMut<crate::v2_5::types::WeatherRadarSettingsCommandStatusMt> for WeatherRadarSettingsCommandStatus {
	fn as_mut(&mut self) -> &mut crate::v2_5::types::WeatherRadarSettingsCommandStatusMt {
		&mut self.0
	}
}
impl From<crate::v2_5::types::WeatherRadarSettingsCommandStatusMt> for WeatherRadarSettingsCommandStatus {
	fn from(p: crate::v2_5::types::WeatherRadarSettingsCommandStatusMt) -> Self {
		Self(p)
	}
}
impl Into<crate::v2_5::types::WeatherRadarSettingsCommandStatusMt> for WeatherRadarSettingsCommandStatus {
	fn into(self) -> crate::v2_5::types::WeatherRadarSettingsCommandStatusMt {
		self.0
	}
}