sapient-rs 0.1.0

// This file is @generated by prost-build.
/// \[START messages\]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AssociatedDetection {
    /// UTC timestamp the message was sent
    #[prost(message, optional, tag = "1")]
    pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
    /// ULID for the node where the assoicated detection has originiated
    #[prost(string, optional, tag = "2")]
    pub node_id: ::core::option::Option<::prost::alloc::string::String>,
    /// ULID for the object detected in the environment
    #[prost(string, optional, tag = "3")]
    pub object_id: ::core::option::Option<::prost::alloc::string::String>,
    /// Relationship of associated detection to this message
    #[prost(enumeration = "AssociationRelation", optional, tag = "4")]
    pub association_type: ::core::option::Option<i32>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AssociationRelation {
    /// Unset enum
    Unspecified = 0,
    NoRelation = 1,
    Parent = 2,
    Child = 3,
    Sibling = 4,
}
impl AssociationRelation {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "ASSOCIATION_RELATION_UNSPECIFIED",
            Self::NoRelation => "ASSOCIATION_RELATION_NO_RELATION",
            Self::Parent => "ASSOCIATION_RELATION_PARENT",
            Self::Child => "ASSOCIATION_RELATION_CHILD",
            Self::Sibling => "ASSOCIATION_RELATION_SIBLING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ASSOCIATION_RELATION_UNSPECIFIED" => Some(Self::Unspecified),
            "ASSOCIATION_RELATION_NO_RELATION" => Some(Self::NoRelation),
            "ASSOCIATION_RELATION_PARENT" => Some(Self::Parent),
            "ASSOCIATION_RELATION_CHILD" => Some(Self::Child),
            "ASSOCIATION_RELATION_SIBLING" => Some(Self::Sibling),
            _ => None,
        }
    }
}
/// \[START messages\]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AssociatedFile {
    /// Type of file contained available at the URL
    #[prost(string, optional, tag = "1")]
    pub r#type: ::core::option::Option<::prost::alloc::string::String>,
    /// The network address of where the file can be accessed
    #[prost(string, optional, tag = "2")]
    pub url: ::core::option::Option<::prost::alloc::string::String>,
}
/// \[START messages\]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LocationList {
    /// List of locations used to define a region
    #[prost(message, repeated, tag = "1")]
    pub locations: ::prost::alloc::vec::Vec<Location>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Location {
    /// X-coordinate (normally longitude)
    #[prost(double, optional, tag = "1")]
    pub x: ::core::option::Option<f64>,
    /// Y-coordinate (normally latitude)
    #[prost(double, optional, tag = "2")]
    pub y: ::core::option::Option<f64>,
    /// Z-coordinate (normally altitude)
    #[prost(double, optional, tag = "3")]
    pub z: ::core::option::Option<f64>,
    /// X-coordinate error
    #[prost(double, optional, tag = "4")]
    pub x_error: ::core::option::Option<f64>,
    /// Y-coordinate error
    #[prost(double, optional, tag = "5")]
    pub y_error: ::core::option::Option<f64>,
    /// Z-coordinate error
    #[prost(double, optional, tag = "6")]
    pub z_error: ::core::option::Option<f64>,
    /// Coordinate system used
    #[prost(enumeration = "LocationCoordinateSystem", optional, tag = "7")]
    pub coordinate_system: ::core::option::Option<i32>,
    /// Datum used
    #[prost(enumeration = "LocationDatum", optional, tag = "8")]
    pub datum: ::core::option::Option<i32>,
    /// For reporting locations in an adjacent UTM zone
    #[prost(string, optional, tag = "9")]
    pub utm_zone: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LocationCoordinateSystem {
    /// Co-ordinate system/units not defined
    Unspecified = 0,
    /// Latitude/Longitude in decimal-degrees/metres
    LatLngDegM = 1,
    /// Latitude/Longitude in radians/metres
    LatLngRadM = 2,
    ///     LOCATION_COORDINATE_SYSTEM_LAT_LNG_DEG_F = 3; // Latitude/Longitude in decimal-degrees/feet - DEPRECATED
    ///     LOCATION_COORDINATE_SYSTEM_LAT_LNG_RAD_F = 4; // Latitude/Longitude in radians/feet - DEPRECATED
    ///
    /// UTM with altitude in metres
    UtmM = 5,
}
impl LocationCoordinateSystem {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "LOCATION_COORDINATE_SYSTEM_UNSPECIFIED",
            Self::LatLngDegM => "LOCATION_COORDINATE_SYSTEM_LAT_LNG_DEG_M",
            Self::LatLngRadM => "LOCATION_COORDINATE_SYSTEM_LAT_LNG_RAD_M",
            Self::UtmM => "LOCATION_COORDINATE_SYSTEM_UTM_M",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "LOCATION_COORDINATE_SYSTEM_UNSPECIFIED" => Some(Self::Unspecified),
            "LOCATION_COORDINATE_SYSTEM_LAT_LNG_DEG_M" => Some(Self::LatLngDegM),
            "LOCATION_COORDINATE_SYSTEM_LAT_LNG_RAD_M" => Some(Self::LatLngRadM),
            "LOCATION_COORDINATE_SYSTEM_UTM_M" => Some(Self::UtmM),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LocationDatum {
    /// Datum not defined
    Unspecified = 0,
    /// WGS84 Ellipsoid
    Wgs84E = 1,
    /// WGS84 Geoid
    Wgs84G = 2,
}
impl LocationDatum {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "LOCATION_DATUM_UNSPECIFIED",
            Self::Wgs84E => "LOCATION_DATUM_WGS84_E",
            Self::Wgs84G => "LOCATION_DATUM_WGS84_G",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "LOCATION_DATUM_UNSPECIFIED" => Some(Self::Unspecified),
            "LOCATION_DATUM_WGS84_E" => Some(Self::Wgs84E),
            "LOCATION_DATUM_WGS84_G" => Some(Self::Wgs84G),
            _ => None,
        }
    }
}
/// \[START messages\]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RangeBearing {
    /// Elevation in relation to node's horizon
    #[prost(double, optional, tag = "1")]
    pub elevation: ::core::option::Option<f64>,
    /// Azimuth in relation to the node's north
    #[prost(double, optional, tag = "2")]
    pub azimuth: ::core::option::Option<f64>,
    /// Range from the node's location
    #[prost(double, optional, tag = "3")]
    pub range: ::core::option::Option<f64>,
    /// Elevation error
    #[prost(double, optional, tag = "4")]
    pub elevation_error: ::core::option::Option<f64>,
    /// Azimuth error
    #[prost(double, optional, tag = "5")]
    pub azimuth_error: ::core::option::Option<f64>,
    /// Range Error
    #[prost(double, optional, tag = "6")]
    pub range_error: ::core::option::Option<f64>,
    /// Units used by the range bearing
    #[prost(enumeration = "RangeBearingCoordinateSystem", optional, tag = "7")]
    pub coordinate_system: ::core::option::Option<i32>,
    /// Datum or 'north' used by the range bearing
    #[prost(enumeration = "RangeBearingDatum", optional, tag = "8")]
    pub datum: ::core::option::Option<i32>,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RangeBearingCone {
    /// Elevation in relation to node's horizon
    #[prost(double, optional, tag = "1")]
    pub elevation: ::core::option::Option<f64>,
    /// Azimuth in relation to the node's north
    #[prost(double, optional, tag = "2")]
    pub azimuth: ::core::option::Option<f64>,
    /// Range from the node's location
    #[prost(double, optional, tag = "3")]
    pub range: ::core::option::Option<f64>,
    /// Horizontal extent angle in degrees
    #[prost(double, optional, tag = "4")]
    pub horizontal_extent: ::core::option::Option<f64>,
    /// Vertical extent angle in degrees
    #[prost(double, optional, tag = "5")]
    pub vertical_extent: ::core::option::Option<f64>,
    /// Error in the horizontal extent
    #[prost(double, optional, tag = "6")]
    pub horizontal_extent_error: ::core::option::Option<f64>,
    /// Error in the vertical extent
    #[prost(double, optional, tag = "7")]
    pub vertical_extent_error: ::core::option::Option<f64>,
    /// Elevation error
    #[prost(double, optional, tag = "8")]
    pub elevation_error: ::core::option::Option<f64>,
    /// Azimuth error
    #[prost(double, optional, tag = "9")]
    pub azimuth_error: ::core::option::Option<f64>,
    /// Range Error
    #[prost(double, optional, tag = "10")]
    pub range_error: ::core::option::Option<f64>,
    /// Units used by the range bearing
    #[prost(enumeration = "RangeBearingCoordinateSystem", optional, tag = "11")]
    pub coordinate_system: ::core::option::Option<i32>,
    /// Datum or 'north' used by the range bearing
    #[prost(enumeration = "RangeBearingDatum", optional, tag = "12")]
    pub datum: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LocationOrRangeBearing {
    #[prost(oneof = "location_or_range_bearing::FovOneof", tags = "1, 2")]
    pub fov_oneof: ::core::option::Option<location_or_range_bearing::FovOneof>,
}
/// Nested message and enum types in `LocationOrRangeBearing`.
pub mod location_or_range_bearing {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum FovOneof {
        /// Location in Spherical coordinates
        #[prost(message, tag = "1")]
        RangeBearing(super::RangeBearingCone),
        /// Location in Geo coordinates
        #[prost(message, tag = "2")]
        LocationList(super::LocationList),
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RangeBearingCoordinateSystem {
    /// Co-ordinate system/units not defined
    Unspecified = 0,
    /// Values in decimal-degrees and meters
    DegreesM = 1,
    /// Values in radians and meters
    RadiansM = 2,
    /// Values in decimal-degrees and kilometers
    DegreesKm = 3,
    /// Values in radians and kilometers
    RadiansKm = 4,
}
impl RangeBearingCoordinateSystem {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "RANGE_BEARING_COORDINATE_SYSTEM_UNSPECIFIED",
            Self::DegreesM => "RANGE_BEARING_COORDINATE_SYSTEM_DEGREES_M",
            Self::RadiansM => "RANGE_BEARING_COORDINATE_SYSTEM_RADIANS_M",
            Self::DegreesKm => "RANGE_BEARING_COORDINATE_SYSTEM_DEGREES_KM",
            Self::RadiansKm => "RANGE_BEARING_COORDINATE_SYSTEM_RADIANS_KM",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "RANGE_BEARING_COORDINATE_SYSTEM_UNSPECIFIED" => Some(Self::Unspecified),
            "RANGE_BEARING_COORDINATE_SYSTEM_DEGREES_M" => Some(Self::DegreesM),
            "RANGE_BEARING_COORDINATE_SYSTEM_RADIANS_M" => Some(Self::RadiansM),
            "RANGE_BEARING_COORDINATE_SYSTEM_DEGREES_KM" => Some(Self::DegreesKm),
            "RANGE_BEARING_COORDINATE_SYSTEM_RADIANS_KM" => Some(Self::RadiansKm),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RangeBearingDatum {
    /// Datum not defined
    Unspecified = 0,
    /// True North
    True = 1,
    /// Magnetic North
    Magnetic = 2,
    /// Grid North
    Grid = 3,
    /// 'North' is the heading of the platform carrying the node
    Platform = 4,
}
impl RangeBearingDatum {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "RANGE_BEARING_DATUM_UNSPECIFIED",
            Self::True => "RANGE_BEARING_DATUM_TRUE",
            Self::Magnetic => "RANGE_BEARING_DATUM_MAGNETIC",
            Self::Grid => "RANGE_BEARING_DATUM_GRID",
            Self::Platform => "RANGE_BEARING_DATUM_PLATFORM",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "RANGE_BEARING_DATUM_UNSPECIFIED" => Some(Self::Unspecified),
            "RANGE_BEARING_DATUM_TRUE" => Some(Self::True),
            "RANGE_BEARING_DATUM_MAGNETIC" => Some(Self::Magnetic),
            "RANGE_BEARING_DATUM_GRID" => Some(Self::Grid),
            "RANGE_BEARING_DATUM_PLATFORM" => Some(Self::Platform),
            _ => None,
        }
    }
}
/// \[START messages\]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Alert {
    /// ULID for the message
    #[prost(string, optional, tag = "1")]
    pub alert_id: ::core::option::Option<::prost::alloc::string::String>,
    /// Type of alert message
    #[prost(enumeration = "alert::AlertType", optional, tag = "2")]
    pub alert_type: ::core::option::Option<i32>,
    /// State of the information in this message
    #[prost(enumeration = "alert::AlertStatus", optional, tag = "3")]
    pub status: ::core::option::Option<i32>,
    /// Description of the alert (normally displayed on a GUI)
    #[prost(string, optional, tag = "4")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    /// ULID of the region the alert is from
    #[prost(string, optional, tag = "7")]
    pub region_id: ::core::option::Option<::prost::alloc::string::String>,
    /// Priority of the alert
    #[prost(enumeration = "alert::DiscretePriority", optional, tag = "8")]
    pub priority: ::core::option::Option<i32>,
    /// 0-1
    #[prost(float, optional, tag = "9")]
    pub ranking: ::core::option::Option<f32>,
    /// Confidence (0-1) that the alert is not a false-alarm
    #[prost(float, optional, tag = "10")]
    pub confidence: ::core::option::Option<f32>,
    /// URL linking to any files associated with the alert
    #[prost(message, repeated, tag = "11")]
    pub associated_file: ::prost::alloc::vec::Vec<AssociatedFile>,
    /// Detections associated with the alert
    #[prost(message, repeated, tag = "12")]
    pub associated_detection: ::prost::alloc::vec::Vec<AssociatedDetection>,
    /// Any additional information that may be useful for the alert consumer
    #[prost(string, optional, tag = "13")]
    pub additional_information: ::core::option::Option<::prost::alloc::string::String>,
    /// The position of the event/object that caused the alert
    #[prost(oneof = "alert::LocationOneof", tags = "5, 6")]
    pub location_oneof: ::core::option::Option<alert::LocationOneof>,
}
/// Nested message and enum types in `Alert`.
pub mod alert {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum AlertType {
        /// Unset enum
        Unspecified = 0,
        Information = 1,
        Warning = 2,
        Critical = 3,
        Error = 4,
        Fatal = 5,
        ModeChange = 6,
    }
    impl AlertType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "ALERT_TYPE_UNSPECIFIED",
                Self::Information => "ALERT_TYPE_INFORMATION",
                Self::Warning => "ALERT_TYPE_WARNING",
                Self::Critical => "ALERT_TYPE_CRITICAL",
                Self::Error => "ALERT_TYPE_ERROR",
                Self::Fatal => "ALERT_TYPE_FATAL",
                Self::ModeChange => "ALERT_TYPE_MODE_CHANGE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ALERT_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "ALERT_TYPE_INFORMATION" => Some(Self::Information),
                "ALERT_TYPE_WARNING" => Some(Self::Warning),
                "ALERT_TYPE_CRITICAL" => Some(Self::Critical),
                "ALERT_TYPE_ERROR" => Some(Self::Error),
                "ALERT_TYPE_FATAL" => Some(Self::Fatal),
                "ALERT_TYPE_MODE_CHANGE" => Some(Self::ModeChange),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum AlertStatus {
        /// Unset enum
        Unspecified = 0,
        Active = 1,
        Acknowledge = 2,
        Reject = 3,
        Ignore = 4,
        Clear = 5,
    }
    impl AlertStatus {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "ALERT_STATUS_UNSPECIFIED",
                Self::Active => "ALERT_STATUS_ACTIVE",
                Self::Acknowledge => "ALERT_STATUS_ACKNOWLEDGE",
                Self::Reject => "ALERT_STATUS_REJECT",
                Self::Ignore => "ALERT_STATUS_IGNORE",
                Self::Clear => "ALERT_STATUS_CLEAR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ALERT_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "ALERT_STATUS_ACTIVE" => Some(Self::Active),
                "ALERT_STATUS_ACKNOWLEDGE" => Some(Self::Acknowledge),
                "ALERT_STATUS_REJECT" => Some(Self::Reject),
                "ALERT_STATUS_IGNORE" => Some(Self::Ignore),
                "ALERT_STATUS_CLEAR" => Some(Self::Clear),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum DiscretePriority {
        /// Alert priority not set
        Unspecified = 0,
        /// Low alert priority
        Low = 1,
        /// Medium alert priority
        Medium = 2,
        /// High alert priority
        High = 3,
    }
    impl DiscretePriority {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "DISCRETE_PRIORITY_UNSPECIFIED",
                Self::Low => "DISCRETE_PRIORITY_LOW",
                Self::Medium => "DISCRETE_PRIORITY_MEDIUM",
                Self::High => "DISCRETE_PRIORITY_HIGH",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DISCRETE_PRIORITY_UNSPECIFIED" => Some(Self::Unspecified),
                "DISCRETE_PRIORITY_LOW" => Some(Self::Low),
                "DISCRETE_PRIORITY_MEDIUM" => Some(Self::Medium),
                "DISCRETE_PRIORITY_HIGH" => Some(Self::High),
                _ => None,
            }
        }
    }
    /// The position of the event/object that caused the alert
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum LocationOneof {
        /// Location of the alert in Sphereical coordinates
        #[prost(message, tag = "5")]
        RangeBearing(super::RangeBearing),
        /// Location of the alert in Geo coordinates
        #[prost(message, tag = "6")]
        Location(super::Location),
    }
}
/// \[START messages\]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AlertAck {
    /// ULID for the message
    #[prost(string, optional, tag = "1")]
    pub alert_id: ::core::option::Option<::prost::alloc::string::String>,
    ///     optional AlertStatus alert_status = 2 \[(field_options) = {is_mandatory: true}\]; // State of the information in this message
    ///     optional string reason = 3; // Reason why alert was not accepted
    ///
    /// Reason(s) why alert was not accepted
    #[prost(string, repeated, tag = "4")]
    pub reason: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// State of the information in this message
    #[prost(enumeration = "alert_ack::AlertAckStatus", optional, tag = "5")]
    pub alert_ack_status: ::core::option::Option<i32>,
}
/// Nested message and enum types in `AlertAck`.
pub mod alert_ack {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum AlertAckStatus {
        /// Reason not set
        Unspecified = 0,
        /// Alert accepted
        Accepted = 1,
        /// Alert rejected
        Rejected = 2,
        /// Alert cancelled
        Cancelled = 3,
    }
    impl AlertAckStatus {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "ALERT_ACK_STATUS_UNSPECIFIED",
                Self::Accepted => "ALERT_ACK_STATUS_ACCEPTED",
                Self::Rejected => "ALERT_ACK_STATUS_REJECTED",
                Self::Cancelled => "ALERT_ACK_STATUS_CANCELLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ALERT_ACK_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "ALERT_ACK_STATUS_ACCEPTED" => Some(Self::Accepted),
                "ALERT_ACK_STATUS_REJECTED" => Some(Self::Rejected),
                "ALERT_ACK_STATUS_CANCELLED" => Some(Self::Cancelled),
                _ => None,
            }
        }
    }
}
/// Provide velocity as a vector in global cartesian coordinates
/// This is a revision of the TIE22 LocationVelocity encoding velocity as per the Location field but with eastings, northings and up for clarity.
/// This aligns with the Location (Cartesian) coordinates system.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct EnuVelocity {
    /// Velocity in the east-axis (x)
    #[prost(double, optional, tag = "1")]
    pub east_rate: ::core::option::Option<f64>,
    /// Velocity in the north-axis (y)
    #[prost(double, optional, tag = "2")]
    pub north_rate: ::core::option::Option<f64>,
    /// Velocity in the up-axis (z)
    #[prost(double, optional, tag = "3")]
    pub up_rate: ::core::option::Option<f64>,
    /// Error in the velocity in the east-axis
    #[prost(double, optional, tag = "4")]
    pub east_rate_error: ::core::option::Option<f64>,
    /// Error in the velocity in the north-axis
    #[prost(double, optional, tag = "5")]
    pub north_rate_error: ::core::option::Option<f64>,
    /// Error in the velocity in the up-axis
    #[prost(double, optional, tag = "6")]
    pub up_rate_error: ::core::option::Option<f64>,
}
/// Specify units when ENUVelocity is in use
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EnuVelocityUnits {
    /// Units that velocity is reported in for east and north axis
    #[prost(enumeration = "SpeedUnits", optional, tag = "1")]
    pub east_north_rate_units: ::core::option::Option<i32>,
    /// Units that velocity is reported in for up axis
    #[prost(enumeration = "SpeedUnits", optional, tag = "2")]
    pub up_rate_units: ::core::option::Option<i32>,
}
/// This specifies the units of the scalar speed component of velocity being reported
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SpeedUnits {
    /// Units not defined
    Unspecified = 0,
    /// Meters per second
    Ms = 1,
    /// Kilometers per hour
    Kph = 2,
}
impl SpeedUnits {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "SPEED_UNITS_UNSPECIFIED",
            Self::Ms => "SPEED_UNITS_MS",
            Self::Kph => "SPEED_UNITS_KPH",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SPEED_UNITS_UNSPECIFIED" => Some(Self::Unspecified),
            "SPEED_UNITS_MS" => Some(Self::Ms),
            "SPEED_UNITS_KPH" => Some(Self::Kph),
            _ => None,
        }
    }
}
/// \[START messages\]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DetectionReport {
    /// ULID for the message
    #[prost(string, optional, tag = "1")]
    pub report_id: ::core::option::Option<::prost::alloc::string::String>,
    /// ULID for the object detected in the environment
    #[prost(string, optional, tag = "2")]
    pub object_id: ::core::option::Option<::prost::alloc::string::String>,
    /// ULID of the task the ASM is currently performing
    #[prost(string, optional, tag = "3")]
    pub task_id: ::core::option::Option<::prost::alloc::string::String>,
    /// Whether a special case is in effect (e.g. object lost)
    #[prost(string, optional, tag = "4")]
    pub state: ::core::option::Option<::prost::alloc::string::String>,
    /// The confidence that the detection is present as a percentage (0-1)
    #[prost(float, optional, tag = "7")]
    pub detection_confidence: ::core::option::Option<f32>,
    /// Additional information about the track as defined in the ASM's registration message
    #[prost(message, repeated, tag = "8")]
    pub track_info: ::prost::alloc::vec::Vec<detection_report::TrackObjectInfo>,
    /// Location where the object is predicted to be at a future time
    #[prost(message, optional, tag = "9")]
    pub prediction_location: ::core::option::Option<detection_report::PredictedLocation>,
    /// Additional information about the detected object as defined in the ASM's registration message
    #[prost(message, repeated, tag = "10")]
    pub object_info: ::prost::alloc::vec::Vec<detection_report::TrackObjectInfo>,
    /// Classification information about the detected object
    #[prost(message, repeated, tag = "11")]
    pub classification: ::prost::alloc::vec::Vec<detection_report::DetectionReportClassification>,
    /// Behavioural information about the detected object
    #[prost(message, repeated, tag = "12")]
    pub behaviour: ::prost::alloc::vec::Vec<detection_report::Behaviour>,
    /// URLs to any additional files relating to the object which hosted on the network
    #[prost(message, repeated, tag = "13")]
    pub associated_file: ::prost::alloc::vec::Vec<AssociatedFile>,
    /// RF signal information about the detected object
    #[prost(message, repeated, tag = "14")]
    pub signal: ::prost::alloc::vec::Vec<detection_report::Signal>,
    /// Other SAPIENT detections associated with this detection
    #[prost(message, repeated, tag = "15")]
    pub associated_detection: ::prost::alloc::vec::Vec<AssociatedDetection>,
    /// Other SAPIENT detections dervied from this detection
    #[prost(message, repeated, tag = "16")]
    pub derived_detection: ::prost::alloc::vec::Vec<detection_report::DerivedDetection>,
    /// Colour of the object being reported
    #[prost(string, optional, tag = "22")]
    pub colour: ::core::option::Option<::prost::alloc::string::String>,
    /// ID of the object being reported (e.g. the tail number of aircraft)
    #[prost(string, optional, tag = "23")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(oneof = "detection_report::LocationOneof", tags = "5, 6")]
    pub location_oneof: ::core::option::Option<detection_report::LocationOneof>,
    #[prost(oneof = "detection_report::VelocityOneof", tags = "19")]
    pub velocity_oneof: ::core::option::Option<detection_report::VelocityOneof>,
}
/// Nested message and enum types in `DetectionReport`.
pub mod detection_report {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct PredictedLocation {
        /// The timestamp of when the detected object will be at the predicted location
        #[prost(message, optional, tag = "3")]
        pub predicted_timestamp: ::core::option::Option<::prost_types::Timestamp>,
        #[prost(oneof = "predicted_location::PredictedLocationOneof", tags = "1, 2")]
        pub predicted_location_oneof:
            ::core::option::Option<predicted_location::PredictedLocationOneof>,
    }
    /// Nested message and enum types in `PredictedLocation`.
    pub mod predicted_location {
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum PredictedLocationOneof {
            /// Predicted location of object being detected using an range-bearing coordinate system
            #[prost(message, tag = "1")]
            RangeBearing(super::super::RangeBearing),
            /// Predicted location of object being detected using an 'x-y-z' coordinate system
            #[prost(message, tag = "2")]
            Location(super::super::Location),
        }
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct TrackObjectInfo {
        /// The type of object_info being reported (e.g. colour)
        #[prost(string, optional, tag = "1")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// The value of the object_info being reported (e.g. red)
        #[prost(string, optional, tag = "2")]
        pub value: ::core::option::Option<::prost::alloc::string::String>,
        /// Any error associated with the object_info
        #[prost(float, optional, tag = "3")]
        pub error: ::core::option::Option<f32>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DetectionReportClassification {
        /// Classification of the detected object being reported
        #[prost(string, optional, tag = "1")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// Confidence (0-1) that this is the correct classification of the detected object
        #[prost(float, optional, tag = "2")]
        pub confidence: ::core::option::Option<f32>,
        /// Any sub-classifications of the detected object
        #[prost(message, repeated, tag = "3")]
        pub sub_class: ::prost::alloc::vec::Vec<SubClass>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SubClass {
        /// Classification of the detected object being reported
        #[prost(string, optional, tag = "1")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// Confidence (0-1) that this is the correct classification of the detected object
        #[prost(float, optional, tag = "2")]
        pub confidence: ::core::option::Option<f32>,
        /// The level of sub-classification (top level is 0, the first sub-class is 1, etc.)
        #[prost(int32, optional, tag = "3")]
        pub level: ::core::option::Option<i32>,
        /// Any sub-classifications of the detected object
        #[prost(message, repeated, tag = "4")]
        pub sub_class: ::prost::alloc::vec::Vec<SubClass>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Behaviour {
        /// Behviouar of the detected object being reported
        #[prost(string, optional, tag = "1")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// Confidence (0-1) that this is the correct behvaiour of the detected object
        #[prost(float, optional, tag = "2")]
        pub confidence: ::core::option::Option<f32>,
    }
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct Signal {
        /// Peak amplitude of the signal being reported
        #[prost(float, optional, tag = "1")]
        pub amplitude: ::core::option::Option<f32>,
        /// Lowest frequency of the band being reported
        #[prost(float, optional, tag = "2")]
        pub start_frequency: ::core::option::Option<f32>,
        /// Centre frequency of the band being reported
        #[prost(float, optional, tag = "3")]
        pub centre_frequency: ::core::option::Option<f32>,
        /// Highest frequency of the band being reported
        #[prost(float, optional, tag = "4")]
        pub stop_frequency: ::core::option::Option<f32>,
        /// Pulse duration of the signal being reported
        #[prost(float, optional, tag = "5")]
        pub pulse_duration: ::core::option::Option<f32>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DerivedDetection {
        /// UTC timestamp the message was sent
        #[prost(message, optional, tag = "1")]
        pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
        /// UUID for the node where the assoicated detection has originiated
        #[prost(string, optional, tag = "2")]
        pub node_id: ::core::option::Option<::prost::alloc::string::String>,
        /// ULID for the object detected in the environment
        #[prost(string, optional, tag = "3")]
        pub object_id: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum LocationOneof {
        /// Location of object being detected using an range-bearing coordinate system
        #[prost(message, tag = "5")]
        RangeBearing(super::RangeBearing),
        /// Location of object being detected using an 'x-y-z' coordinate system
        #[prost(message, tag = "6")]
        Location(super::Location),
    }
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum VelocityOneof {
        ///         RYPVelocity ryp_velocity = 17; // Velocity of object relative to sensor location and sensor pointing direction
        ///         GHCVelocity ghc_velocity = 18; // Velocity of object in global coordinates in the style of Air Traffic Management
        ///
        /// Velocity of object as a vector in global cartesian coordinates
        #[prost(message, tag = "19")]
        EnuVelocity(super::EnuVelocity),
    }
}
/// \[START messages\]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Error {
    /// Packet which caused the error
    #[prost(bytes = "vec", optional, tag = "1")]
    pub packet: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
    ///     optional string error_message = 2 \[(field_options) = {is_mandatory: true}\]; // Description of the error being reported
    ///
    /// Description of the error being reported, this field is an array to allow multiple errors to be reported in one go
    #[prost(string, repeated, tag = "3")]
    pub error_message: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Registration {
    /// Type of the node
    #[prost(message, repeated, tag = "1")]
    pub node_definition: ::prost::alloc::vec::Vec<registration::NodeDefinition>,
    /// ICD version implemented by the node
    #[prost(string, optional, tag = "2")]
    pub icd_version: ::core::option::Option<::prost::alloc::string::String>,
    /// System name
    #[prost(string, optional, tag = "3")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    /// Shortened version of the system name suitable for GUIs
    #[prost(string, optional, tag = "4")]
    pub short_name: ::core::option::Option<::prost::alloc::string::String>,
    /// Node's capabilities
    #[prost(message, repeated, tag = "5")]
    pub capabilities: ::prost::alloc::vec::Vec<registration::Capability>,
    /// Status report definition
    #[prost(message, optional, tag = "6")]
    pub status_definition: ::core::option::Option<registration::StatusDefinition>,
    /// Detection report and tasking definitons
    #[prost(message, repeated, tag = "7")]
    pub mode_definition: ::prost::alloc::vec::Vec<registration::ModeDefinition>,
    /// This field allows the dependent (child) nodes (if present) of the current node to be specified
    #[prost(string, repeated, tag = "8")]
    pub dependent_nodes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// This field is used within a hierarchy of fusion nodes for a (child) fusion node to tell its parent fusion node the region it is reporting from
    #[prost(message, repeated, tag = "9")]
    pub reporting_region: ::prost::alloc::vec::Vec<LocationOrRangeBearing>,
    /// This sub-message is used to report node configuration data, e.g. Manufacturer, Model, etc
    #[prost(message, repeated, tag = "10")]
    pub config_data: ::prost::alloc::vec::Vec<registration::ConfigurationData>,
}
/// Nested message and enum types in `Registration`.
pub mod registration {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct NodeDefinition {
        /// Description of major type of the node
        #[prost(enumeration = "NodeType", optional, tag = "1")]
        pub node_type: ::core::option::Option<i32>,
        /// further description of node type
        #[prost(string, repeated, tag = "2")]
        pub node_sub_type: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Capability {
        /// The category of field to report (e.g. Radar, Jammer, etc.)
        #[prost(string, optional, tag = "1")]
        pub category: ::core::option::Option<::prost::alloc::string::String>,
        /// Description of the capability (e.g. Maximum Transmit Power)
        #[prost(string, optional, tag = "2")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// The value of the capability (e.g. 50)
        #[prost(string, optional, tag = "3")]
        pub value: ::core::option::Option<::prost::alloc::string::String>,
        /// The units of the value that will be reported (e.g. dB)
        #[prost(string, optional, tag = "4")]
        pub units: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct StatusDefinition {
        /// Time between heartbeats
        #[prost(message, optional, tag = "1")]
        pub status_interval: ::core::option::Option<Duration>,
        /// Node location definition
        #[prost(message, optional, tag = "2")]
        pub location_definition: ::core::option::Option<LocationType>,
        /// Area covered by the ASM definition
        #[prost(message, optional, tag = "3")]
        pub coverage_definition: ::core::option::Option<LocationType>,
        /// Area obsucred to ASM definition
        #[prost(message, optional, tag = "4")]
        pub obscuration_definition: ::core::option::Option<LocationType>,
        /// Additional heartbeat report definitions
        #[prost(message, repeated, tag = "5")]
        pub status_report: ::prost::alloc::vec::Vec<StatusReport>,
        /// ASM's field of view definition
        #[prost(message, optional, tag = "6")]
        pub field_of_view_definition: ::core::option::Option<LocationType>,
    }
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct Duration {
        /// Units that the duration are specified in
        #[prost(enumeration = "TimeUnits", optional, tag = "1")]
        pub units: ::core::option::Option<i32>,
        ///         int32 value = 2; // Amount of time being specified for the duration
        ///
        /// Amount of time being specified for the duration
        #[prost(float, optional, tag = "3")]
        pub value: ::core::option::Option<f32>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ModeParameter {
        /// Type of parameter (e.g. SelfAdaptation)
        #[prost(string, optional, tag = "1")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// Allowed values of parameter (e.g. ROI, Range)
        #[prost(string, optional, tag = "2")]
        pub value: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct LocationType {
        /// If using UTM coordinates, provide the UTM zone in this field (e.g. 30N)
        #[prost(string, optional, tag = "5")]
        pub zone: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(oneof = "location_type::CoordinatesOneof", tags = "1, 2")]
        pub coordinates_oneof: ::core::option::Option<location_type::CoordinatesOneof>,
        #[prost(oneof = "location_type::DatumOneof", tags = "3, 4")]
        pub datum_oneof: ::core::option::Option<location_type::DatumOneof>,
    }
    /// Nested message and enum types in `LocationType`.
    pub mod location_type {
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum CoordinatesOneof {
            /// Units of location
            #[prost(enumeration = "super::super::LocationCoordinateSystem", tag = "1")]
            LocationUnits(i32),
            /// Units of range bearing
            #[prost(enumeration = "super::super::RangeBearingCoordinateSystem", tag = "2")]
            RangeBearingUnits(i32),
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum DatumOneof {
            /// Datum of location
            #[prost(enumeration = "super::super::LocationDatum", tag = "3")]
            LocationDatum(i32),
            /// Datum of range bearing
            #[prost(enumeration = "super::super::RangeBearingDatum", tag = "4")]
            RangeBearingDatum(i32),
        }
    }
    /// Specify how velocity is provided by specifying the coordinates system type and units in use
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct VelocityType {
        /// If using UTM coordinates, provide the UTM zone in this field (e.g. 30N)
        #[prost(string, optional, tag = "8")]
        pub zone: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(oneof = "velocity_type::VelocityUnitsOneof", tags = "4")]
        pub velocity_units_oneof: ::core::option::Option<velocity_type::VelocityUnitsOneof>,
        #[prost(oneof = "velocity_type::DatumOneof", tags = "6, 7")]
        pub datum_oneof: ::core::option::Option<velocity_type::DatumOneof>,
    }
    /// Nested message and enum types in `VelocityType`.
    pub mod velocity_type {
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum VelocityUnitsOneof {
            ///             	GHCVelocityUnits ghc_velocity_units = 1; // Provide velocity in global coordinates in the style of Air Traffic Management and specify units - DEPRECIATED
            /// 		        RYPVelocityUnits ryp_units = 2; // Provide velocity relative to sensor location and sensor pointing direction and specify units - DEPRECIATED
            /// 		        RAEVelocityUnits rae_units = 3; // Provide velocity relative to sensor location and ground plane - DEPRECIATED
            ///
            /// Provide velocity as a vector in global spherical coordinates and specify units
            #[prost(message, tag = "4")]
            EnuVelocityUnits(super::super::EnuVelocityUnits),
        }
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum DatumOneof {
            /// Datum of velocity in Cartesian coordinates
            #[prost(enumeration = "super::super::LocationDatum", tag = "6")]
            LocationDatum(i32),
            /// Datum of velocity in Spherical coordinates
            #[prost(enumeration = "super::super::RangeBearingDatum", tag = "7")]
            RangeBearingDatum(i32),
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct StatusReport {
        /// Category of the field to report in the status report (e.g. sensor, power, mode, status, etc.)
        #[prost(enumeration = "StatusReportCategory", optional, tag = "1")]
        pub category: ::core::option::Option<i32>,
        /// Type or name of the information being provide
        #[prost(string, optional, tag = "2")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// Units or valid values that will be reported
        #[prost(string, optional, tag = "3")]
        pub units: ::core::option::Option<::prost::alloc::string::String>,
        /// Is a new status report sent when a value changes
        #[prost(bool, optional, tag = "4")]
        pub on_change: ::core::option::Option<bool>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ModeDefinition {
        /// Mode's name
        #[prost(string, optional, tag = "1")]
        pub mode_name: ::core::option::Option<::prost::alloc::string::String>,
        /// Mode's type
        #[prost(enumeration = "ModeType", optional, tag = "2")]
        pub mode_type: ::core::option::Option<i32>,
        /// Description of the mode (normally used by GUIs)
        #[prost(string, optional, tag = "3")]
        pub mode_description: ::core::option::Option<::prost::alloc::string::String>,
        /// Time required for the ASM to change to this mode
        #[prost(message, optional, tag = "4")]
        pub settle_time: ::core::option::Option<Duration>,
        /// Maximum expected latency from a detection being made by the sensor to a message being sent
        #[prost(message, optional, tag = "5")]
        pub maximum_latency: ::core::option::Option<Duration>,
        /// Type of scan. Typically: fixed or scanning
        #[prost(enumeration = "ScanType", optional, tag = "6")]
        pub scan_type: ::core::option::Option<i32>,
        /// Type of scan
        #[prost(enumeration = "TrackingType", optional, tag = "7")]
        pub tracking_type: ::core::option::Option<i32>,
        /// Time the mode lasts for in the case of temporary modes
        #[prost(message, optional, tag = "8")]
        pub duration: ::core::option::Option<Duration>,
        /// Additional parameters that can be passed to the mode during tasking
        #[prost(message, repeated, tag = "9")]
        pub mode_parameter: ::prost::alloc::vec::Vec<ModeParameter>,
        /// Definition of detection reports sent while in this mode
        #[prost(message, repeated, tag = "10")]
        pub detection_definition: ::prost::alloc::vec::Vec<DetectionDefinition>,
        /// Definition of tasks that can be accepted by the ASM while in this mode
        #[prost(message, optional, tag = "11")]
        pub task: ::core::option::Option<TaskDefinition>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DetectionDefinition {
        /// Type of location that is reported in the detection report
        #[prost(message, optional, tag = "1")]
        pub location_type: ::core::option::Option<LocationType>,
        /// detection performance definition
        #[prost(message, repeated, tag = "2")]
        pub detection_performance: ::prost::alloc::vec::Vec<PerformanceValue>,
        /// Detection report defintion
        #[prost(message, repeated, tag = "3")]
        pub detection_report: ::prost::alloc::vec::Vec<DetectionReport>,
        /// Classes able to be reported in this detection report
        #[prost(message, repeated, tag = "4")]
        pub detection_class_definition: ::prost::alloc::vec::Vec<DetectionClassDefinition>,
        /// Behaviours able to be reported in the detection report
        #[prost(message, repeated, tag = "5")]
        pub behaviour_definition: ::prost::alloc::vec::Vec<BehaviourDefinition>,
        /// Type of velocity that is reported in the detection report
        #[prost(message, optional, tag = "6")]
        pub velocity_type: ::core::option::Option<VelocityType>,
        /// List of location error charaterisations to allow the DMM to understand the detection performance of the ASM
        #[prost(message, optional, tag = "7")]
        pub geometric_error: ::core::option::Option<GeometricError>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct GeometricError {
        /// Type of the performance value being specified (e.g. Standard Deviation)
        #[prost(string, optional, tag = "1")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// Units of the performance value being specified (e.g. metres)
        #[prost(string, optional, tag = "2")]
        pub units: ::core::option::Option<::prost::alloc::string::String>,
        /// How the performance value being specified may vary during operation (e.g. Linear with Range)
        #[prost(string, optional, tag = "3")]
        pub variation_type: ::core::option::Option<::prost::alloc::string::String>,
        /// A list of types and values
        #[prost(message, repeated, tag = "4")]
        pub performance_value: ::prost::alloc::vec::Vec<PerformanceValue>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct PerformanceValue {
        /// Type of the performance value being specified (e.g. Rotation speed)
        #[prost(string, optional, tag = "1")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// Units of the performance value being specified (e.g. Degrees per second)
        #[prost(string, optional, tag = "2")]
        pub units: ::core::option::Option<::prost::alloc::string::String>,
        /// Typical unit value of the performance value being specified (e.g. 2.5)
        #[prost(string, optional, tag = "3")]
        pub unit_value: ::core::option::Option<::prost::alloc::string::String>,
        /// How the performance value being specified may vary during operation (e.g. Linear)
        #[prost(string, optional, tag = "4")]
        pub variation_type: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DetectionReport {
        /// Category of detection field being reported (e.g. object_info)
        #[prost(enumeration = "DetectionReportCategory", optional, tag = "1")]
        pub category: ::core::option::Option<i32>,
        /// Type of detection field being reported (e.g. colour)
        #[prost(string, optional, tag = "2")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// Units of detection field being reported (e.f. "Red, Green, Blue, Yellow...")
        #[prost(string, optional, tag = "3")]
        pub units: ::core::option::Option<::prost::alloc::string::String>,
        /// Is a new detection report sent when a value changes
        #[prost(bool, optional, tag = "4")]
        pub on_change: ::core::option::Option<bool>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DetectionClassDefinition {
        /// A flag to note what type of confidences the ASM will provide for classifications
        #[prost(enumeration = "ConfidenceDefinition", optional, tag = "1")]
        pub confidence_definition: ::core::option::Option<i32>,
        /// Performance values associated with the classifications in the detection
        #[prost(message, repeated, tag = "2")]
        pub class_performance: ::prost::alloc::vec::Vec<PerformanceValue>,
        /// Classifications the ASM is able to provide
        #[prost(message, repeated, tag = "3")]
        pub class_definition: ::prost::alloc::vec::Vec<ClassDefinition>,
        /// List of docking points for taxonomy extensions
        #[prost(message, repeated, tag = "4")]
        pub taxonomy_dock_definition: ::prost::alloc::vec::Vec<TaxonomyDockDefinition>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ClassDefinition {
        /// Name of the classification that can be reported
        #[prost(string, optional, tag = "1")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// The units of any reported confidence that the classification is correct (e.g. represented as a decimal (0-1))
        #[prost(string, optional, tag = "2")]
        pub units: ::core::option::Option<::prost::alloc::string::String>,
        /// Any classes further down the taxonomy tree that can be reported
        #[prost(message, repeated, tag = "3")]
        pub sub_class: ::prost::alloc::vec::Vec<SubClass>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SubClass {
        /// Name of the classification that can be reported
        #[prost(string, optional, tag = "1")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// The units of any reported confidence that the classification is correct (e.g. represented as a decimal (0-1))
        #[prost(string, optional, tag = "2")]
        pub units: ::core::option::Option<::prost::alloc::string::String>,
        /// The level of the sub-class. The top-level class would have a sub-level of: 0, the next: 1, etc.
        #[prost(int32, optional, tag = "3")]
        pub level: ::core::option::Option<i32>,
        /// Any classes further down the taxonomy tree that can be reported
        #[prost(message, repeated, tag = "4")]
        pub sub_class: ::prost::alloc::vec::Vec<SubClass>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct BehaviourDefinition {
        /// Name of the behaviour that can be reported
        #[prost(string, optional, tag = "1")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// The units of any reported confidence that the behaviour is correct (e.g. represented as a decimal (0-1))
        #[prost(string, optional, tag = "2")]
        pub units: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct TaskDefinition {
        /// The number of instances of this task that can be run at the same time
        #[prost(int32, optional, tag = "1")]
        pub concurrent_tasks: ::core::option::Option<i32>,
        /// Region definition for regions this task can operate on
        #[prost(message, optional, tag = "2")]
        pub region_definition: ::core::option::Option<RegionDefinition>,
        /// Commands that can be issued as part of this task
        #[prost(message, repeated, tag = "3")]
        pub command: ::prost::alloc::vec::Vec<Command>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ClassFilterDefinition {
        /// Parameter to be filtered on
        #[prost(message, repeated, tag = "1")]
        pub filter_parameter: ::prost::alloc::vec::Vec<FilterParameter>,
        /// List of sub-class filters
        #[prost(message, repeated, tag = "2")]
        pub sub_class_definition: ::prost::alloc::vec::Vec<SubClassFilterDefinition>,
        /// Classification name to be filtered on
        #[prost(string, optional, tag = "3")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SubClassFilterDefinition {
        /// Parameter to be filtered on
        #[prost(message, repeated, tag = "1")]
        pub filter_parameter: ::prost::alloc::vec::Vec<FilterParameter>,
        /// Level of sub-class filter
        #[prost(int32, optional, tag = "2")]
        pub level: ::core::option::Option<i32>,
        /// Classification name to be filtered on
        #[prost(string, optional, tag = "3")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// List of sub-class filters
        #[prost(message, repeated, tag = "4")]
        pub sub_class_definition: ::prost::alloc::vec::Vec<SubClassFilterDefinition>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct FilterParameter {
        /// Parameter to be filtered
        #[prost(string, optional, tag = "1")]
        pub parameter: ::core::option::Option<::prost::alloc::string::String>,
        /// Operaters to filter parameter on
        #[prost(enumeration = "super::Operator", repeated, packed = "false", tag = "2")]
        pub operators: ::prost::alloc::vec::Vec<i32>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BehaviourFilterDefinition {
        /// Parameter to be filtered on
        #[prost(message, repeated, tag = "1")]
        pub filter_parameter: ::prost::alloc::vec::Vec<FilterParameter>,
        /// Behvaiour name to be filtered on
        #[prost(string, optional, tag = "2")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Command {
        /// optional string name = 1 \[(field_options) = {is_mandatory: true}\]; // Name of command
        ///
        /// Units or allowable values of the command
        #[prost(string, optional, tag = "2")]
        pub units: ::core::option::Option<::prost::alloc::string::String>,
        /// Time allowed to complete command
        #[prost(message, optional, tag = "3")]
        pub completion_time: ::core::option::Option<Duration>,
        /// The type of command
        #[prost(enumeration = "CommandType", optional, tag = "4")]
        pub r#type: ::core::option::Option<i32>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RegionDefinition {
        /// Types of region
        #[prost(enumeration = "RegionType", repeated, packed = "false", tag = "1")]
        pub region_type: ::prost::alloc::vec::Vec<i32>,
        /// Time to settle to normal performance in this mode
        #[prost(message, optional, tag = "2")]
        pub settle_time: ::core::option::Option<Duration>,
        /// Location types used for the area that defines the region
        #[prost(message, repeated, tag = "3")]
        pub region_area: ::prost::alloc::vec::Vec<LocationType>,
        /// Filters that can be applied to the region for classes
        #[prost(message, repeated, tag = "4")]
        pub class_filter_definition: ::prost::alloc::vec::Vec<ClassFilterDefinition>,
        /// Filters that can be applied to the region for behaviours
        #[prost(message, repeated, tag = "5")]
        pub behaviour_filter_definition: ::prost::alloc::vec::Vec<BehaviourFilterDefinition>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct TaxonomyDockDefinition {
        #[prost(string, optional, tag = "1")]
        pub dock_class_namespace: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(string, optional, tag = "2")]
        pub dock_class: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, repeated, tag = "3")]
        pub extension_subclass: ::prost::alloc::vec::Vec<ExtensionSubclass>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ExtensionSubclass {
        #[prost(string, optional, tag = "1")]
        pub subclass_namespace: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(string, optional, tag = "2")]
        pub subclass_name: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(string, optional, tag = "3")]
        pub units: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ConfigurationData {
        /// The name of the manufacturer of the node
        #[prost(string, tag = "1")]
        pub manufacturer: ::prost::alloc::string::String,
        /// The name of the model of the node
        #[prost(string, tag = "2")]
        pub model: ::prost::alloc::string::String,
        /// The serial number of the node
        #[prost(string, optional, tag = "3")]
        pub serial_number: ::core::option::Option<::prost::alloc::string::String>,
        /// The hardware version of the node
        #[prost(string, optional, tag = "4")]
        pub hardware_version: ::core::option::Option<::prost::alloc::string::String>,
        /// The software version of the node
        #[prost(string, optional, tag = "5")]
        pub software_version: ::core::option::Option<::prost::alloc::string::String>,
        /// Configuration data of any sub-components
        #[prost(message, repeated, tag = "6")]
        pub sub_components: ::prost::alloc::vec::Vec<ConfigurationData>,
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum NodeType {
        /// No node type specified
        Unspecified = 0,
        /// A node type not defined in another enumeration
        Other = 1,
        /// A radar-based system (such as an air traffic control radar)
        Radar = 2,
        /// A sensor that uses light to determine the range to objects in a scene
        Lidar = 3,
        /// An camera-based system (such as an electro-optical or infra-red camera)
        Camera = 4,
        /// A system based on the detection of vibrations in the local environment (such as a seismometer)
        Seismic = 5,
        /// A system based on acoustic signals (such as a microphone or speaker)
        Acoustic = 6,
        /// A system which can detect the local present of objects (such as a trip-wire)
        ProximitySensor = 7,
        /// A system based on the passive interception of radio-frequency signals
        PassiveRf = 8,
        /// A human acting as part of a SAPIENT system (such as a spotter or guard)
        Human = 9,
        /// A system that can detect chemical signatures
        Chemical = 10,
        /// A system that can detect biological signatures
        Biological = 11,
        /// A system that can detect radioactive signatures (such as a Geiger counter)
        Radiation = 12,
        /// A system which has a physical effector (such as a missile or collision-based system)
        Kinetic = 13,
        /// A radio-frequency transmitter that disrupts other systems using power
        Jammer = 14,
        /// A system which uses network/communication protocols to detect or effect other systems
        Cyber = 15,
        /// A Laser Directed Energy Weapon
        Ldew = 16,
        /// A Radio Frequency Directed Energy Weapon
        Rfdew = 17,
        /// A (platform) node that can be moved to a new location
        MobileNode = 18,
        /// A node that can be pointed in different directions, e.g. a gimball
        PointableNode = 19,
        /// A (child) Fusion Node. This is used when creating a hierarchy of Fusion Nodes and the child Fusion Node registers with a parent Fusion Node
        FusionNode = 20,
    }
    impl NodeType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "NODE_TYPE_UNSPECIFIED",
                Self::Other => "NODE_TYPE_OTHER",
                Self::Radar => "NODE_TYPE_RADAR",
                Self::Lidar => "NODE_TYPE_LIDAR",
                Self::Camera => "NODE_TYPE_CAMERA",
                Self::Seismic => "NODE_TYPE_SEISMIC",
                Self::Acoustic => "NODE_TYPE_ACOUSTIC",
                Self::ProximitySensor => "NODE_TYPE_PROXIMITY_SENSOR",
                Self::PassiveRf => "NODE_TYPE_PASSIVE_RF",
                Self::Human => "NODE_TYPE_HUMAN",
                Self::Chemical => "NODE_TYPE_CHEMICAL",
                Self::Biological => "NODE_TYPE_BIOLOGICAL",
                Self::Radiation => "NODE_TYPE_RADIATION",
                Self::Kinetic => "NODE_TYPE_KINETIC",
                Self::Jammer => "NODE_TYPE_JAMMER",
                Self::Cyber => "NODE_TYPE_CYBER",
                Self::Ldew => "NODE_TYPE_LDEW",
                Self::Rfdew => "NODE_TYPE_RFDEW",
                Self::MobileNode => "NODE_TYPE_MOBILE_NODE",
                Self::PointableNode => "NODE_TYPE_POINTABLE_NODE",
                Self::FusionNode => "NODE_TYPE_FUSION_NODE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "NODE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "NODE_TYPE_OTHER" => Some(Self::Other),
                "NODE_TYPE_RADAR" => Some(Self::Radar),
                "NODE_TYPE_LIDAR" => Some(Self::Lidar),
                "NODE_TYPE_CAMERA" => Some(Self::Camera),
                "NODE_TYPE_SEISMIC" => Some(Self::Seismic),
                "NODE_TYPE_ACOUSTIC" => Some(Self::Acoustic),
                "NODE_TYPE_PROXIMITY_SENSOR" => Some(Self::ProximitySensor),
                "NODE_TYPE_PASSIVE_RF" => Some(Self::PassiveRf),
                "NODE_TYPE_HUMAN" => Some(Self::Human),
                "NODE_TYPE_CHEMICAL" => Some(Self::Chemical),
                "NODE_TYPE_BIOLOGICAL" => Some(Self::Biological),
                "NODE_TYPE_RADIATION" => Some(Self::Radiation),
                "NODE_TYPE_KINETIC" => Some(Self::Kinetic),
                "NODE_TYPE_JAMMER" => Some(Self::Jammer),
                "NODE_TYPE_CYBER" => Some(Self::Cyber),
                "NODE_TYPE_LDEW" => Some(Self::Ldew),
                "NODE_TYPE_RFDEW" => Some(Self::Rfdew),
                "NODE_TYPE_MOBILE_NODE" => Some(Self::MobileNode),
                "NODE_TYPE_POINTABLE_NODE" => Some(Self::PointableNode),
                "NODE_TYPE_FUSION_NODE" => Some(Self::FusionNode),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum TimeUnits {
        /// Time units not specified
        Unspecified = 0,
        /// Nano Seconds
        Nanoseconds = 1,
        /// Micro Seconds
        Microseconds = 2,
        /// Milli Seconds
        Milliseconds = 3,
        /// Seconds
        Seconds = 4,
        /// Minutes
        Minutes = 5,
        /// Hours
        Hours = 6,
        /// Days
        Days = 7,
    }
    impl TimeUnits {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "TIME_UNITS_UNSPECIFIED",
                Self::Nanoseconds => "TIME_UNITS_NANOSECONDS",
                Self::Microseconds => "TIME_UNITS_MICROSECONDS",
                Self::Milliseconds => "TIME_UNITS_MILLISECONDS",
                Self::Seconds => "TIME_UNITS_SECONDS",
                Self::Minutes => "TIME_UNITS_MINUTES",
                Self::Hours => "TIME_UNITS_HOURS",
                Self::Days => "TIME_UNITS_DAYS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TIME_UNITS_UNSPECIFIED" => Some(Self::Unspecified),
                "TIME_UNITS_NANOSECONDS" => Some(Self::Nanoseconds),
                "TIME_UNITS_MICROSECONDS" => Some(Self::Microseconds),
                "TIME_UNITS_MILLISECONDS" => Some(Self::Milliseconds),
                "TIME_UNITS_SECONDS" => Some(Self::Seconds),
                "TIME_UNITS_MINUTES" => Some(Self::Minutes),
                "TIME_UNITS_HOURS" => Some(Self::Hours),
                "TIME_UNITS_DAYS" => Some(Self::Days),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum StatusReportCategory {
        Unspecified = 0,
        /// Sensor fields which can be reported
        Sensor = 1,
        /// Power fields which can be reported
        Power = 2,
        /// Modes which the can be reported in the status report message
        Mode = 3,
        /// Status fields which can be reported
        Status = 4,
    }
    impl StatusReportCategory {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATUS_REPORT_CATEGORY_UNSPECIFIED",
                Self::Sensor => "STATUS_REPORT_CATEGORY_SENSOR",
                Self::Power => "STATUS_REPORT_CATEGORY_POWER",
                Self::Mode => "STATUS_REPORT_CATEGORY_MODE",
                Self::Status => "STATUS_REPORT_CATEGORY_STATUS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_REPORT_CATEGORY_UNSPECIFIED" => Some(Self::Unspecified),
                "STATUS_REPORT_CATEGORY_SENSOR" => Some(Self::Sensor),
                "STATUS_REPORT_CATEGORY_POWER" => Some(Self::Power),
                "STATUS_REPORT_CATEGORY_MODE" => Some(Self::Mode),
                "STATUS_REPORT_CATEGORY_STATUS" => Some(Self::Status),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum ModeType {
        /// Mode type not specified
        Unspecified = 0,
        /// Mode is continous and will not change until the node is re-tasked
        Permanent = 1,
        /// Mode is temporary and will revert to another node once the mode's duration is reached
        Temporary = 2,
        /// The default mode which is permanent until changed
        Default = 3,
    }
    impl ModeType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "MODE_TYPE_UNSPECIFIED",
                Self::Permanent => "MODE_TYPE_PERMANENT",
                Self::Temporary => "MODE_TYPE_TEMPORARY",
                Self::Default => "MODE_TYPE_DEFAULT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MODE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "MODE_TYPE_PERMANENT" => Some(Self::Permanent),
                "MODE_TYPE_TEMPORARY" => Some(Self::Temporary),
                "MODE_TYPE_DEFAULT" => Some(Self::Default),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum ScanType {
        /// Scan type not specified
        Unspecified = 0,
        /// Mode has a fixed field of view that does not change and all regions are detected at all times (e.g. a fixed camera)
        Fixed = 1,
        /// Mode has a moving field of view that will only detect part of a region at any given time (e.g. a rotating radar)
        Scanning = 2,
        /// Mode has a field of view that can be moved (e.g. a pan-tilt-zoom camera)
        Steerable = 3,
    }
    impl ScanType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "SCAN_TYPE_UNSPECIFIED",
                Self::Fixed => "SCAN_TYPE_FIXED",
                Self::Scanning => "SCAN_TYPE_SCANNING",
                Self::Steerable => "SCAN_TYPE_STEERABLE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SCAN_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "SCAN_TYPE_FIXED" => Some(Self::Fixed),
                "SCAN_TYPE_SCANNING" => Some(Self::Scanning),
                "SCAN_TYPE_STEERABLE" => Some(Self::Steerable),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum TrackingType {
        /// Tracking type is not defined
        Unspecified = 0,
        /// No data assocation between detections of the same object. A unique object_id is generated for each detection
        None = 1,
        /// ASM will attempt to persist an object_id between detections of the same object, but will not attempt to join broken tracks
        Tracklet = 2,
        /// ASM is able to persist an object_id between detections of the same object, even when tracks are broken
        Track = 3,
        /// ASM is able to provide tracks that cna be re-associated based on features
        TrackWithReId = 4,
    }
    impl TrackingType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "TRACKING_TYPE_UNSPECIFIED",
                Self::None => "TRACKING_TYPE_NONE",
                Self::Tracklet => "TRACKING_TYPE_TRACKLET",
                Self::Track => "TRACKING_TYPE_TRACK",
                Self::TrackWithReId => "TRACKING_TYPE_TRACK_WITH_RE_ID",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TRACKING_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "TRACKING_TYPE_NONE" => Some(Self::None),
                "TRACKING_TYPE_TRACKLET" => Some(Self::Tracklet),
                "TRACKING_TYPE_TRACK" => Some(Self::Track),
                "TRACKING_TYPE_TRACK_WITH_RE_ID" => Some(Self::TrackWithReId),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum DetectionReportCategory {
        /// Detection report category not specified
        Unspecified = 0,
        /// Detection fields
        Detection = 1,
        /// Track Info fields
        Track = 2,
        /// Object Info fields
        Object = 3,
        /// signal info fields
        Signal = 4,
    }
    impl DetectionReportCategory {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "DETECTION_REPORT_CATEGORY_UNSPECIFIED",
                Self::Detection => "DETECTION_REPORT_CATEGORY_DETECTION",
                Self::Track => "DETECTION_REPORT_CATEGORY_TRACK",
                Self::Object => "DETECTION_REPORT_CATEGORY_OBJECT",
                Self::Signal => "DETECTION_REPORT_CATEGORY_SIGNAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DETECTION_REPORT_CATEGORY_UNSPECIFIED" => Some(Self::Unspecified),
                "DETECTION_REPORT_CATEGORY_DETECTION" => Some(Self::Detection),
                "DETECTION_REPORT_CATEGORY_TRACK" => Some(Self::Track),
                "DETECTION_REPORT_CATEGORY_OBJECT" => Some(Self::Object),
                "DETECTION_REPORT_CATEGORY_SIGNAL" => Some(Self::Signal),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum ConfidenceDefinition {
        /// Confidence definition not specified
        Unspecified = 0,
        /// ASM will only provide confidence for the most likely class
        SingleClass = 1,
        /// ASM will provide confidence for all classes
        MultiClass = 2,
    }
    impl ConfidenceDefinition {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "CONFIDENCE_DEFINITION_UNSPECIFIED",
                Self::SingleClass => "CONFIDENCE_DEFINITION_SINGLE_CLASS",
                Self::MultiClass => "CONFIDENCE_DEFINITION_MULTI_CLASS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CONFIDENCE_DEFINITION_UNSPECIFIED" => Some(Self::Unspecified),
                "CONFIDENCE_DEFINITION_SINGLE_CLASS" => Some(Self::SingleClass),
                "CONFIDENCE_DEFINITION_MULTI_CLASS" => Some(Self::MultiClass),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum CommandType {
        /// No command type set
        Unspecified = 0,
        /// The request being asked for
        Request = 1,
        /// The requested sensitivity of sensor during the task
        DetectionThreshold = 2,
        /// The requested reporting rate of sensor during the task
        DetectionReportRate = 3,
        /// The requested classification sensitivity of sensor during the task
        ClassificationThreshold = 4,
        /// Mode change for the ASM
        ModeChange = 5,
        /// LookAt command for tasking pointing ASMs
        LookAt = 6,
        /// This command is to move a mobile node to a new location
        MoveTo = 7,
        /// This command is to have a mobile node continually patrol a specified route, until a new command is received
        Patrol = 8,
        /// This command is to have a mobile node follow a moving object
        Follow = 9,
    }
    impl CommandType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "COMMAND_TYPE_UNSPECIFIED",
                Self::Request => "COMMAND_TYPE_REQUEST",
                Self::DetectionThreshold => "COMMAND_TYPE_DETECTION_THRESHOLD",
                Self::DetectionReportRate => "COMMAND_TYPE_DETECTION_REPORT_RATE",
                Self::ClassificationThreshold => "COMMAND_TYPE_CLASSIFICATION_THRESHOLD",
                Self::ModeChange => "COMMAND_TYPE_MODE_CHANGE",
                Self::LookAt => "COMMAND_TYPE_LOOK_AT",
                Self::MoveTo => "COMMAND_TYPE_MOVE_TO",
                Self::Patrol => "COMMAND_TYPE_PATROL",
                Self::Follow => "COMMAND_TYPE_FOLLOW",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "COMMAND_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "COMMAND_TYPE_REQUEST" => Some(Self::Request),
                "COMMAND_TYPE_DETECTION_THRESHOLD" => Some(Self::DetectionThreshold),
                "COMMAND_TYPE_DETECTION_REPORT_RATE" => Some(Self::DetectionReportRate),
                "COMMAND_TYPE_CLASSIFICATION_THRESHOLD" => Some(Self::ClassificationThreshold),
                "COMMAND_TYPE_MODE_CHANGE" => Some(Self::ModeChange),
                "COMMAND_TYPE_LOOK_AT" => Some(Self::LookAt),
                "COMMAND_TYPE_MOVE_TO" => Some(Self::MoveTo),
                "COMMAND_TYPE_PATROL" => Some(Self::Patrol),
                "COMMAND_TYPE_FOLLOW" => Some(Self::Follow),
                _ => None,
            }
        }
    }
    ///
    /// Note: enum RegionType also features in task.proto, if making changes to this enumeration, identical changes must be made
    /// in the same enumeration in task.proto. Users should be aware, future versions of the SAPIENT proto files may be
    /// restructured so that enum RegionType only appears once.
    ///
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum RegionType {
        /// No region type set
        Unspecified = 0,
        /// Region is of particular interest
        AreaOfInterest = 1,
        /// Region to be ignored
        Ignore = 2,
        /// Region defines the boundary of the area of operations
        Boundary = 3,
        /// Region defines an area that mobile nodes shall not enter
        MobileNodeNoGoArea = 4,
        /// Region defines an area that mobile nodes shall remain within
        MobileNodeGoArea = 5,
    }
    impl RegionType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "REGION_TYPE_UNSPECIFIED",
                Self::AreaOfInterest => "REGION_TYPE_AREA_OF_INTEREST",
                Self::Ignore => "REGION_TYPE_IGNORE",
                Self::Boundary => "REGION_TYPE_BOUNDARY",
                Self::MobileNodeNoGoArea => "REGION_TYPE_MOBILE_NODE_NO_GO_AREA",
                Self::MobileNodeGoArea => "REGION_TYPE_MOBILE_NODE_GO_AREA",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "REGION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "REGION_TYPE_AREA_OF_INTEREST" => Some(Self::AreaOfInterest),
                "REGION_TYPE_IGNORE" => Some(Self::Ignore),
                "REGION_TYPE_BOUNDARY" => Some(Self::Boundary),
                "REGION_TYPE_MOBILE_NODE_NO_GO_AREA" => Some(Self::MobileNodeNoGoArea),
                "REGION_TYPE_MOBILE_NODE_GO_AREA" => Some(Self::MobileNodeGoArea),
                _ => None,
            }
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Operator {
    Unspecified = 0,
    All = 1,
    GreaterThan = 2,
    LessThan = 3,
    Equal = 4,
}
impl Operator {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "OPERATOR_UNSPECIFIED",
            Self::All => "OPERATOR_ALL",
            Self::GreaterThan => "OPERATOR_GREATER_THAN",
            Self::LessThan => "OPERATOR_LESS_THAN",
            Self::Equal => "OPERATOR_EQUAL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "OPERATOR_UNSPECIFIED" => Some(Self::Unspecified),
            "OPERATOR_ALL" => Some(Self::All),
            "OPERATOR_GREATER_THAN" => Some(Self::GreaterThan),
            "OPERATOR_LESS_THAN" => Some(Self::LessThan),
            "OPERATOR_EQUAL" => Some(Self::Equal),
            _ => None,
        }
    }
}
/// \[START messages\]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RegistrationAck {
    /// This value shall be 0 if the registration is rejected, or 1 if the registration is accepted
    #[prost(bool, optional, tag = "1")]
    pub acceptance: ::core::option::Option<bool>,
    ///   optional string ack_response_reason = 2; // This field can be used to communicate the reason for non-registration
    ///
    /// This field can be used to communicate the (operational) reason(s) for rejecting the Registration Message (one per array element)
    #[prost(string, repeated, tag = "3")]
    pub ack_response_reason: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// \[START messages\]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StatusReport {
    /// ULID for the message
    #[prost(string, optional, tag = "1")]
    pub report_id: ::core::option::Option<::prost::alloc::string::String>,
    /// Current ASM status
    #[prost(enumeration = "status_report::System", optional, tag = "2")]
    pub system: ::core::option::Option<i32>,
    /// State of the information in this message
    #[prost(enumeration = "status_report::Info", optional, tag = "3")]
    pub info: ::core::option::Option<i32>,
    /// ULID of the task the ASM is currently performing
    #[prost(string, optional, tag = "4")]
    pub active_task_id: ::core::option::Option<::prost::alloc::string::String>,
    /// The current mode of the ASM
    #[prost(string, optional, tag = "5")]
    pub mode: ::core::option::Option<::prost::alloc::string::String>,
    /// The power supply of the ASM
    #[prost(message, optional, tag = "6")]
    pub power: ::core::option::Option<status_report::Power>,
    /// Current ASM location
    #[prost(message, optional, tag = "7")]
    pub node_location: ::core::option::Option<Location>,
    /// Area currently visible to ASM
    #[prost(message, optional, tag = "8")]
    pub field_of_view: ::core::option::Option<LocationOrRangeBearing>,
    ///     optional LocationOrRangeBearing coverage = 9; // Area that the ASM can cover
    ///
    /// Area that the ASM cannot cover
    #[prost(message, repeated, tag = "10")]
    pub obscuration: ::prost::alloc::vec::Vec<LocationOrRangeBearing>,
    /// Information about the ASM or the envionrment
    #[prost(message, repeated, tag = "11")]
    pub status: ::prost::alloc::vec::Vec<status_report::Status>,
    /// The coverage field has been made repeated so that a Fusion Node can report the total coverage from its child/edge nodes
    #[prost(message, repeated, tag = "12")]
    pub coverage: ::prost::alloc::vec::Vec<LocationOrRangeBearing>,
}
/// Nested message and enum types in `StatusReport`.
pub mod status_report {
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Power {
        ///         optional string source = 1; // Power source (e.g. battery/mains)
        ///         optional string status = 2; // Power supply status
        ///
        /// Battery level 0-100
        #[prost(int32, optional, tag = "3")]
        pub level: ::core::option::Option<i32>,
        /// The power source being used by the node
        #[prost(enumeration = "PowerSource", tag = "4")]
        pub source: i32,
        /// The status of the power source being used by the node
        #[prost(enumeration = "PowerStatus", tag = "5")]
        pub status: i32,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Status {
        /// Information level being reported
        #[prost(enumeration = "StatusLevel", optional, tag = "1")]
        pub status_level: ::core::option::Option<i32>,
        ///         optional string status_type = 2 \[(field_options) = {is_mandatory: true}\]; // Type of the information being reported (e.g. Weather)
        ///
        /// Value of the information being reported (e.g. Raining)
        #[prost(string, optional, tag = "3")]
        pub status_value: ::core::option::Option<::prost::alloc::string::String>,
        /// Type of the information being reported (e.g. Weather)
        #[prost(enumeration = "StatusType", optional, tag = "4")]
        pub status_type: ::core::option::Option<i32>,
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum System {
        /// The system state is unset
        Unspecified = 0,
        /// The system is operating normally
        Ok = 1,
        /// There is a potential issue with the system
        Warning = 2,
        /// There is an issue with the system
        Error = 3,
        ///         SYSTEM_TAMPER = 4; // The system has been tampered with - DEPRECIATED
        ///
        /// The system is about to disconnect
        Goodbye = 5,
    }
    impl System {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "SYSTEM_UNSPECIFIED",
                Self::Ok => "SYSTEM_OK",
                Self::Warning => "SYSTEM_WARNING",
                Self::Error => "SYSTEM_ERROR",
                Self::Goodbye => "SYSTEM_GOODBYE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SYSTEM_UNSPECIFIED" => Some(Self::Unspecified),
                "SYSTEM_OK" => Some(Self::Ok),
                "SYSTEM_WARNING" => Some(Self::Warning),
                "SYSTEM_ERROR" => Some(Self::Error),
                "SYSTEM_GOODBYE" => Some(Self::Goodbye),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum PowerSource {
        /// The PowerSource is unset
        PowersourceUnspecified = 0,
        /// The power source is of a different type listed in this enumeration
        PowersourceOther = 1,
        /// The power source is the mains (fixed infrastructure)
        PowersourceMains = 2,
        /// The power source is a battery contained within the node
        PowersourceInternalBattery = 3,
        /// The power source is a battery external to the node
        PowersourceExternalBattery = 4,
        /// The power source is a generator
        PowersourceGenerator = 5,
        /// The power source is a solar photovoltaic panel/array
        PowersourceSolarPv = 6,
        /// The power source is a wind turbine
        PowersourceWindTurbine = 7,
        /// The power source is a fuel cell
        PowersourceFuelCell = 8,
    }
    impl PowerSource {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::PowersourceUnspecified => "POWERSOURCE_UNSPECIFIED",
                Self::PowersourceOther => "POWERSOURCE_OTHER",
                Self::PowersourceMains => "POWERSOURCE_MAINS",
                Self::PowersourceInternalBattery => "POWERSOURCE_INTERNAL_BATTERY",
                Self::PowersourceExternalBattery => "POWERSOURCE_EXTERNAL_BATTERY",
                Self::PowersourceGenerator => "POWERSOURCE_GENERATOR",
                Self::PowersourceSolarPv => "POWERSOURCE_SOLAR_PV",
                Self::PowersourceWindTurbine => "POWERSOURCE_WIND_TURBINE",
                Self::PowersourceFuelCell => "POWERSOURCE_FUEL_CELL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "POWERSOURCE_UNSPECIFIED" => Some(Self::PowersourceUnspecified),
                "POWERSOURCE_OTHER" => Some(Self::PowersourceOther),
                "POWERSOURCE_MAINS" => Some(Self::PowersourceMains),
                "POWERSOURCE_INTERNAL_BATTERY" => Some(Self::PowersourceInternalBattery),
                "POWERSOURCE_EXTERNAL_BATTERY" => Some(Self::PowersourceExternalBattery),
                "POWERSOURCE_GENERATOR" => Some(Self::PowersourceGenerator),
                "POWERSOURCE_SOLAR_PV" => Some(Self::PowersourceSolarPv),
                "POWERSOURCE_WIND_TURBINE" => Some(Self::PowersourceWindTurbine),
                "POWERSOURCE_FUEL_CELL" => Some(Self::PowersourceFuelCell),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum PowerStatus {
        /// The PowerStatus is unset
        PowerstatusUnspecified = 0,
        /// The power status is normal
        PowerstatusOk = 1,
        /// There is a fault with the power source
        PowerstatusFault = 2,
    }
    impl PowerStatus {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::PowerstatusUnspecified => "POWERSTATUS_UNSPECIFIED",
                Self::PowerstatusOk => "POWERSTATUS_OK",
                Self::PowerstatusFault => "POWERSTATUS_FAULT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "POWERSTATUS_UNSPECIFIED" => Some(Self::PowerstatusUnspecified),
                "POWERSTATUS_OK" => Some(Self::PowerstatusOk),
                "POWERSTATUS_FAULT" => Some(Self::PowerstatusFault),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Info {
        /// Unset enum
        Unspecified = 0,
        /// New information about the system is being presented
        New = 1,
        /// The existing information about the system is up-to-date
        Unchanged = 2,
    }
    impl Info {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "INFO_UNSPECIFIED",
                Self::New => "INFO_NEW",
                Self::Unchanged => "INFO_UNCHANGED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "INFO_UNSPECIFIED" => Some(Self::Unspecified),
                "INFO_NEW" => Some(Self::New),
                "INFO_UNCHANGED" => Some(Self::Unchanged),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum StatusType {
        /// No status type has been set
        Unspecified = 0,
        /// The node has an internal fault
        InternalFault = 1,
        /// External influences have caused a fault with the node
        ExternalFault = 2,
        ///
        Illumination = 3,
        ///
        Weather = 4,
        ///
        Clutter = 5,
        ///
        Exposure = 6,
        ///
        MotionSensitivity = 7,
        ///
        PtzStatus = 8,
        ///
        Pd = 9,
        ///
        Far = 10,
        /// The node is not detecting
        NotDetecting = 11,
        /// A report about a platform node
        Platform = 12,
        ///
        Other = 13,
    }
    impl StatusType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATUS_TYPE_UNSPECIFIED",
                Self::InternalFault => "STATUS_TYPE_INTERNAL_FAULT",
                Self::ExternalFault => "STATUS_TYPE_EXTERNAL_FAULT",
                Self::Illumination => "STATUS_TYPE_ILLUMINATION",
                Self::Weather => "STATUS_TYPE_WEATHER",
                Self::Clutter => "STATUS_TYPE_CLUTTER",
                Self::Exposure => "STATUS_TYPE_EXPOSURE",
                Self::MotionSensitivity => "STATUS_TYPE_MOTION_SENSITIVITY",
                Self::PtzStatus => "STATUS_TYPE_PTZ_STATUS",
                Self::Pd => "STATUS_TYPE_PD",
                Self::Far => "STATUS_TYPE_FAR",
                Self::NotDetecting => "STATUS_TYPE_NOT_DETECTING",
                Self::Platform => "STATUS_TYPE_PLATFORM",
                Self::Other => "STATUS_TYPE_OTHER",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "STATUS_TYPE_INTERNAL_FAULT" => Some(Self::InternalFault),
                "STATUS_TYPE_EXTERNAL_FAULT" => Some(Self::ExternalFault),
                "STATUS_TYPE_ILLUMINATION" => Some(Self::Illumination),
                "STATUS_TYPE_WEATHER" => Some(Self::Weather),
                "STATUS_TYPE_CLUTTER" => Some(Self::Clutter),
                "STATUS_TYPE_EXPOSURE" => Some(Self::Exposure),
                "STATUS_TYPE_MOTION_SENSITIVITY" => Some(Self::MotionSensitivity),
                "STATUS_TYPE_PTZ_STATUS" => Some(Self::PtzStatus),
                "STATUS_TYPE_PD" => Some(Self::Pd),
                "STATUS_TYPE_FAR" => Some(Self::Far),
                "STATUS_TYPE_NOT_DETECTING" => Some(Self::NotDetecting),
                "STATUS_TYPE_PLATFORM" => Some(Self::Platform),
                "STATUS_TYPE_OTHER" => Some(Self::Other),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum StatusLevel {
        /// No status level has been set
        Unspecified = 0,
        /// STATUS_LEVEL_SENSOR_STATUS = 1; // Information about the current node state
        ///
        /// Information about the environment that might affect this or other nodes
        InformationStatus = 2,
        /// Information about performance degregation of the node
        WarningStatus = 3,
        /// Information about severely affecting this node's capabilities
        ErrorStatus = 4,
    }
    impl StatusLevel {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATUS_LEVEL_UNSPECIFIED",
                Self::InformationStatus => "STATUS_LEVEL_INFORMATION_STATUS",
                Self::WarningStatus => "STATUS_LEVEL_WARNING_STATUS",
                Self::ErrorStatus => "STATUS_LEVEL_ERROR_STATUS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_LEVEL_UNSPECIFIED" => Some(Self::Unspecified),
                "STATUS_LEVEL_INFORMATION_STATUS" => Some(Self::InformationStatus),
                "STATUS_LEVEL_WARNING_STATUS" => Some(Self::WarningStatus),
                "STATUS_LEVEL_ERROR_STATUS" => Some(Self::ErrorStatus),
                _ => None,
            }
        }
    }
}
/// \[START messages\]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FollowObject {
    /// This field specifies the object_id (from the Detection Messages) of the object the mobile node should follow
    #[prost(string, tag = "1")]
    pub follow_object_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Task {
    /// ULID for the task being sent
    #[prost(string, optional, tag = "1")]
    pub task_id: ::core::option::Option<::prost::alloc::string::String>,
    /// Name of the task being requested
    #[prost(string, optional, tag = "2")]
    pub task_name: ::core::option::Option<::prost::alloc::string::String>,
    /// Description of the task being requested
    #[prost(string, optional, tag = "3")]
    pub task_description: ::core::option::Option<::prost::alloc::string::String>,
    /// Time the task is requested to start at
    #[prost(message, optional, tag = "4")]
    pub task_start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Time the task is requested to end at
    #[prost(message, optional, tag = "5")]
    pub task_end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Control action being requested
    #[prost(enumeration = "task::Control", optional, tag = "6")]
    pub control: ::core::option::Option<i32>,
    /// Area tasking is to be applied (such as a system implementing geo-fencing)
    #[prost(message, repeated, tag = "7")]
    pub region: ::prost::alloc::vec::Vec<task::Region>,
    /// Command being requested as part the task
    #[prost(message, optional, tag = "8")]
    pub command: ::core::option::Option<task::Command>,
}
/// Nested message and enum types in `Task`.
pub mod task {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Command {
        /// Parameter string for some commands
        #[prost(string, optional, tag = "8")]
        pub command_parameter: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(oneof = "command::Command", tags = "1, 2, 3, 4, 5, 6, 9, 10, 11")]
        pub command: ::core::option::Option<command::Command>,
    }
    /// Nested message and enum types in `Command`.
    pub mod command {
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Command {
            /// The request being asked for
            #[prost(string, tag = "1")]
            Request(::prost::alloc::string::String),
            /// The requested sensitivity of sensor during the task
            #[prost(enumeration = "super::DiscreteThreshold", tag = "2")]
            DetectionThreshold(i32),
            /// The requested reporting rate of sensor during the task
            #[prost(enumeration = "super::DiscreteThreshold", tag = "3")]
            DetectionReportRate(i32),
            /// The requested classification sensitivity of sensor during the task
            #[prost(enumeration = "super::DiscreteThreshold", tag = "4")]
            ClassificationThreshold(i32),
            /// Mode change for the ASM
            #[prost(string, tag = "5")]
            ModeChange(::prost::alloc::string::String),
            /// LookAt command for tasking pointing ASMs
            #[prost(message, tag = "6")]
            LookAt(super::super::LocationOrRangeBearing),
            /// command for instructing a mobile node to move to a new location
            #[prost(message, tag = "9")]
            MoveTo(super::super::LocationList),
            /// command for instructing a mobile node to continually patrol a route until instructed otherwise
            #[prost(message, tag = "10")]
            Patrol(super::super::LocationList),
            /// command for instructing a mobile node to follow a moving object until instructed otherwise
            #[prost(message, tag = "11")]
            Follow(super::super::FollowObject),
        }
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Region {
        /// Type of region
        #[prost(enumeration = "RegionType", optional, tag = "1")]
        pub r#type: ::core::option::Option<i32>,
        /// Unique ID of region
        #[prost(string, optional, tag = "2")]
        pub region_id: ::core::option::Option<::prost::alloc::string::String>,
        /// Name of region
        #[prost(string, optional, tag = "3")]
        pub region_name: ::core::option::Option<::prost::alloc::string::String>,
        /// Area that defines the region
        #[prost(message, optional, tag = "4")]
        pub region_area: ::core::option::Option<super::LocationOrRangeBearing>,
        /// Filter for classifications detected in the region
        #[prost(message, repeated, tag = "5")]
        pub class_filter: ::prost::alloc::vec::Vec<ClassFilter>,
        /// Filter for behaviours detected in the region
        #[prost(message, repeated, tag = "6")]
        pub behaviour_filter: ::prost::alloc::vec::Vec<BehaviourFilter>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ClassFilter {
        /// Parameter to filter on
        #[prost(message, optional, tag = "1")]
        pub parameter: ::core::option::Option<Parameter>,
        /// Type of classification to filter on
        #[prost(string, optional, tag = "2")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// Sub-classes to filter on
        #[prost(message, repeated, tag = "3")]
        pub sub_class_filter: ::prost::alloc::vec::Vec<SubClassFilter>,
        /// Priority of filter
        #[prost(enumeration = "DiscreteThreshold", optional, tag = "4")]
        pub priority: ::core::option::Option<i32>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SubClassFilter {
        /// Parameter to filter on
        #[prost(message, optional, tag = "1")]
        pub parameter: ::core::option::Option<Parameter>,
        /// Type of classification to filter on
        #[prost(string, optional, tag = "2")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// Sub-classes to filter on
        #[prost(message, repeated, tag = "3")]
        pub sub_class_filter: ::prost::alloc::vec::Vec<SubClassFilter>,
        /// Priority of filter
        #[prost(enumeration = "DiscreteThreshold", optional, tag = "4")]
        pub priority: ::core::option::Option<i32>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BehaviourFilter {
        /// Parameter to filter on
        #[prost(message, optional, tag = "1")]
        pub parameter: ::core::option::Option<Parameter>,
        /// Type of behaviour to filter on
        #[prost(string, optional, tag = "2")]
        pub r#type: ::core::option::Option<::prost::alloc::string::String>,
        /// Priority of filter
        #[prost(enumeration = "DiscreteThreshold", optional, tag = "3")]
        pub priority: ::core::option::Option<i32>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Parameter {
        /// Name of the parameter to filter
        #[prost(string, optional, tag = "1")]
        pub name: ::core::option::Option<::prost::alloc::string::String>,
        /// Operator to be filtered on
        #[prost(enumeration = "super::Operator", optional, tag = "2")]
        pub operator: ::core::option::Option<i32>,
        /// Threshold
        #[prost(float, optional, tag = "3")]
        pub value: ::core::option::Option<f32>,
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Control {
        /// No control set
        Unspecified = 0,
        /// Initialise/start the task
        Start = 1,
        /// Stop the task, remove the definition and revert to the previous task
        Stop = 2,
        /// Stop the task, keep the definition for later use and revert to previous task
        Pause = 3,
    }
    impl Control {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "CONTROL_UNSPECIFIED",
                Self::Start => "CONTROL_START",
                Self::Stop => "CONTROL_STOP",
                Self::Pause => "CONTROL_PAUSE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CONTROL_UNSPECIFIED" => Some(Self::Unspecified),
                "CONTROL_START" => Some(Self::Start),
                "CONTROL_STOP" => Some(Self::Stop),
                "CONTROL_PAUSE" => Some(Self::Pause),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum DiscreteThreshold {
        /// Threshold not set
        Unspecified = 0,
        /// Threshold set to low
        Low = 1,
        /// Threshold set to medium
        Medium = 2,
        /// Threshold set to high
        High = 3,
    }
    impl DiscreteThreshold {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "DISCRETE_THRESHOLD_UNSPECIFIED",
                Self::Low => "DISCRETE_THRESHOLD_LOW",
                Self::Medium => "DISCRETE_THRESHOLD_MEDIUM",
                Self::High => "DISCRETE_THRESHOLD_HIGH",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DISCRETE_THRESHOLD_UNSPECIFIED" => Some(Self::Unspecified),
                "DISCRETE_THRESHOLD_LOW" => Some(Self::Low),
                "DISCRETE_THRESHOLD_MEDIUM" => Some(Self::Medium),
                "DISCRETE_THRESHOLD_HIGH" => Some(Self::High),
                _ => None,
            }
        }
    }
    ///
    /// Note: enum RegionType also features in registration.proto, if making changes to this enumeration, identical changes must be made
    /// in the same enumeration in registration.proto. Users should be aware, future versions of the SAPIENT proto files may be
    /// restructured so that enum RegionType only appears once.
    ///
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum RegionType {
        /// No region type set
        Unspecified = 0,
        /// Region is of particular interest
        AreaOfInterest = 1,
        /// Region to be ignored
        Ignore = 2,
        /// Region defines the boundary of the area of operations
        Boundary = 3,
        /// Region defines an area that mobile nodes shall not enter
        MobileNodeNoGoArea = 4,
        /// Region defines an area that mobile nodes shall remain within
        MobileNodeGoArea = 5,
    }
    impl RegionType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "REGION_TYPE_UNSPECIFIED",
                Self::AreaOfInterest => "REGION_TYPE_AREA_OF_INTEREST",
                Self::Ignore => "REGION_TYPE_IGNORE",
                Self::Boundary => "REGION_TYPE_BOUNDARY",
                Self::MobileNodeNoGoArea => "REGION_TYPE_MOBILE_NODE_NO_GO_AREA",
                Self::MobileNodeGoArea => "REGION_TYPE_MOBILE_NODE_GO_AREA",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "REGION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "REGION_TYPE_AREA_OF_INTEREST" => Some(Self::AreaOfInterest),
                "REGION_TYPE_IGNORE" => Some(Self::Ignore),
                "REGION_TYPE_BOUNDARY" => Some(Self::Boundary),
                "REGION_TYPE_MOBILE_NODE_NO_GO_AREA" => Some(Self::MobileNodeNoGoArea),
                "REGION_TYPE_MOBILE_NODE_GO_AREA" => Some(Self::MobileNodeGoArea),
                _ => None,
            }
        }
    }
}
/// \[START messages\]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TaskAck {
    /// ULID of task that is being acknowledged
    #[prost(string, optional, tag = "1")]
    pub task_id: ::core::option::Option<::prost::alloc::string::String>,
    /// Status of the task (accepted or rejected)
    #[prost(enumeration = "task_ack::TaskStatus", optional, tag = "2")]
    pub task_status: ::core::option::Option<i32>,
    ///   optional string reason = 3; // Reason for the rejection if task is rejected or completed
    ///
    /// File associated with task being acknowledged
    #[prost(message, optional, tag = "4")]
    pub associated_file: ::core::option::Option<AssociatedFile>,
    /// Reason(s) for the rejection if task is rejected, completed, or failed
    #[prost(string, repeated, tag = "5")]
    pub reason: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Nested message and enum types in `TaskAck`.
pub mod task_ack {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum TaskStatus {
        /// Unset enum
        Unspecified = 0,
        /// Task was accepted
        Accepted = 1,
        /// Task was rejected (reason should also be present in the message)
        Rejected = 2,
        /// Task has been completed
        Completed = 3,
        /// A node has previously accepted a task but has been unable to successfully complete it.
        Failed = 4,
    }
    impl TaskStatus {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "TASK_STATUS_UNSPECIFIED",
                Self::Accepted => "TASK_STATUS_ACCEPTED",
                Self::Rejected => "TASK_STATUS_REJECTED",
                Self::Completed => "TASK_STATUS_COMPLETED",
                Self::Failed => "TASK_STATUS_FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TASK_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "TASK_STATUS_ACCEPTED" => Some(Self::Accepted),
                "TASK_STATUS_REJECTED" => Some(Self::Rejected),
                "TASK_STATUS_COMPLETED" => Some(Self::Completed),
                "TASK_STATUS_FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
}
/// \[START messages\]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SapientMessage {
    /// UTC timestamp the message was sent
    #[prost(message, optional, tag = "1")]
    pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
    /// UUID for the node which is sending the message
    #[prost(string, optional, tag = "2")]
    pub node_id: ::core::option::Option<::prost::alloc::string::String>,
    /// UUID for the node being tasked
    #[prost(string, optional, tag = "3")]
    pub destination_id: ::core::option::Option<::prost::alloc::string::String>,
    /// space for additional information
    #[prost(string, optional, tag = "13")]
    pub additional_information: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(
        oneof = "sapient_message::Content",
        tags = "4, 5, 6, 7, 8, 9, 10, 11, 12"
    )]
    pub content: ::core::option::Option<sapient_message::Content>,
}
/// Nested message and enum types in `SapientMessage`.
pub mod sapient_message {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Content {
        /// SAPIENT Registration message
        #[prost(message, tag = "4")]
        Registration(super::Registration),
        /// SAPIENT Registration Acknowledgement message
        #[prost(message, tag = "5")]
        RegistrationAck(super::RegistrationAck),
        /// SAPIENT Status Report message
        #[prost(message, tag = "6")]
        StatusReport(super::StatusReport),
        /// SAPIENT Detection Report message
        #[prost(message, tag = "7")]
        DetectionReport(super::DetectionReport),
        /// SAPIENT Task message
        #[prost(message, tag = "8")]
        Task(super::Task),
        /// SAPIENT Task Acknowledgement message
        #[prost(message, tag = "9")]
        TaskAck(super::TaskAck),
        /// SAPIENT Alert message
        #[prost(message, tag = "10")]
        Alert(super::Alert),
        /// SAPIENT Alert Acknowledgment message
        #[prost(message, tag = "11")]
        AlertAck(super::AlertAck),
        /// SAPIENT Error message
        #[prost(message, tag = "12")]
        Error(super::Error),
    }
}