/*
    Nyx, blazing fast astrodynamics
    Copyright (C) 2021 Christopher Rabotin <christopher.rabotin@gmail.com>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#[derive(Clone, PartialEq, prost::Message)]
pub struct Metadata {
    #[prost(message, optional, tag = "1")]
    pub version: ::core::option::Option<metadata::Version>,
    #[prost(string, tag = "2")]
    pub publisher: prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub date: ::core::option::Option<metadata::CeDate>,
    #[prost(string, tag = "4")]
    pub file_version: prost::alloc::string::String,
    #[prost(bool, tag = "5")]
    pub proprietary: bool,
    #[prost(string, tag = "6")]
    pub comments: prost::alloc::string::String,
}
/// Nested message and enum types in `Metadata`.
pub mod metadata {
    #[derive(Clone, PartialEq, prost::Message)]
    pub struct CeDate {
        #[prost(uint32, tag = "1")]
        pub year: u32,
        #[prost(uint32, tag = "2")]
        pub month: u32,
        #[prost(uint32, tag = "3")]
        pub day: u32,
    }
    #[derive(Clone, PartialEq, prost::Message)]
    pub struct Version {
        #[prost(uint32, tag = "1")]
        pub major: u32,
        #[prost(uint32, tag = "2")]
        pub minor: u32,
        #[prost(uint32, tag = "3")]
        pub patch: u32,
    }
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct Frame {
    /// Center object of this frame, may be a celestial body, a
    /// spacecraft, a ground station, an instrument, etc.
    /// Note that this corresponds to the full path of the object, e.g.
    /// "/EarthMoonBarycenter/Earth/CAPSTONE/Camera1".
    #[prost(string, tag = "1")]
    pub center: prost::alloc::string::String,
    /// Orientation used by this frame (e.g. "J2000", "IAU Earth", etc.)
    #[prost(string, tag = "2")]
    pub orientation: prost::alloc::string::String,
}
/// A constant value, may be used to specify celestial object properties (e.g.
/// GM), or spacecraft properties (e.g. mass).
#[derive(Clone, PartialEq, prost::Message)]
pub struct Constant {
    #[prost(double, tag = "1")]
    pub value: f64,
    #[prost(enumeration = "Unit", tag = "2")]
    pub unit: i32,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct Vector {
    #[prost(double, tag = "1")]
    pub x: f64,
    #[prost(double, tag = "2")]
    pub y: f64,
    #[prost(double, tag = "3")]
    pub z: f64,
    #[prost(enumeration = "Unit", tag = "4")]
    pub unit: i32,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct Vector4 {
    #[prost(double, tag = "1")]
    pub x: f64,
    #[prost(double, tag = "2")]
    pub y: f64,
    #[prost(double, tag = "3")]
    pub z: f64,
    #[prost(double, tag = "4")]
    pub w: f64,
}
/// Used to store coefficients to interpolate a three dimensional vector.
#[derive(Clone, PartialEq, prost::Message)]
pub struct VectorCoefficients {
    #[prost(double, repeated, tag = "1")]
    pub x: prost::alloc::vec::Vec<f64>,
    #[prost(double, repeated, tag = "2")]
    pub y: prost::alloc::vec::Vec<f64>,
    #[prost(double, repeated, tag = "3")]
    pub z: prost::alloc::vec::Vec<f64>,
}
/// Defines an Epoch. For example, DE438 uses the ET system with an DaysJDE
/// representation.
#[derive(Clone, PartialEq, prost::Message)]
pub struct Epoch {
    #[prost(enumeration = "TimeSystem", tag = "1")]
    pub ts: i32,
    #[prost(enumeration = "TimeRepr", tag = "2")]
    pub repr: i32,
    /// Days since the epoch of the repr used. Recommendation: use
    #[prost(int32, tag = "3")]
    pub days: i32,
    /// days for any `seconds` value greater than 86400 seconds.
    ///
    /// Seconds are stored in a double to trivial support
    #[prost(double, tag = "4")]
    pub seconds: f64,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct Equation {
    #[prost(string, tag = "1")]
    pub expression: prost::alloc::string::String,
    #[prost(enumeration = "Unit", tag = "2")]
    pub unit: i32,
    #[prost(map = "string, message", tag = "3")]
    pub constants: ::std::collections::HashMap<prost::alloc::string::String, Constant>,
    #[prost(map = "string, message", tag = "4")]
    pub context: ::std::collections::HashMap<prost::alloc::string::String, Equation>,
}
/// Grouping all units together allow setting a generic unit to a Vector.
/// Note that we try to group the enum numbering in sections. This provides some
/// lee-way for extending the specs to other units, while maintaining some
/// numbering scheme.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, prost::Enumeration)]
#[repr(i32)]
pub enum Unit {
    Dimensionless = 0,
    /// Distance units
    Au = 1,
    Km = 2,
    M = 3,
    Cm = 4,
    Mm = 5,
    /// Velocity units
    KmS = 10,
    MS = 11,
    CmS = 12,
    MmS = 13,
    /// Acceleration units
    KmS2 = 20,
    MS2 = 21,
    CmS2 = 22,
    MmS2 = 23,
    /// Angular units
    Deg = 30,
    Rad = 31,
    /// Angular velocity units
    DegS = 32,
    RadS = 33,
    /// Angular acceleration units
    DegS2 = 34,
    RadS2 = 35,
    /// Frequency units
    Hz = 40,
    KHz = 41,
    MHz = 42,
    Ghz = 43,
    /// Duration units -- anything above days is poorly defined, so we ignore that
    Ns = 50,
    Us = 51,
    Ms = 52,
    S = 53,
    Min = 54,
    H = 55,
    Days = 56,
    /// Other units
    CustomUnit = 60,
    /// Used for gravitational parameters
    Km3S2 = 61,
    N = 62,
}
/// Allows specifying the time system used
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, prost::Enumeration)]
#[repr(i32)]
pub enum TimeSystem {
    /// Temps Atomique International
    Tai = 0,
    /// Ephemeris Time (very slightly different from IERS TDB)
    Et = 1,
    /// Terrestrial Time
    Tt = 2,
    /// Universal Coordinated Time (assumes ALL leap seconds)
    Utc = 3,
    /// Barycentric Dynamical Time (IERS TDB)
    Tdb = 4,
    CustomTs = 5,
}
/// Allow specifying the time representation used
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, prost::Enumeration)]
#[repr(i32)]
pub enum TimeRepr {
    /// Seconds past 01 January 1900 at MIDNIGHT (or TAI Epoch)
    SecondsJ1900 = 0,
    /// Days of 86400.0 seconds past of the Epoch of the time system
    DaysJ1900 = 1,
    /// Seconds past 01 January 2000 at NOON (NOT midnight, hence
    SecondsJ2k = 2,
    /// different notation)
    ///
    /// Days of 86400.0 seconds past 01 January 2000 at NOON (NOT
    DaysJ2k = 3,
    /// midnight, hence different notation)
    ///
    /// Days past the Modified Julian Date Epoch defined as 17
    DaysMjd = 4,
    /// November 1858 at zero hours.
    ///
    /// Days past the Julian Date Epoch.
    DaysJde = 5,
    CustomTimeRepr = 6,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, prost::Enumeration)]
#[repr(i32)]
pub enum InterpType {
    /// Supported interpolations.
    Chebyshev = 0,
    Hermite = 1,
    Polynomial = 2,
    Lagrange = 3,
    Fourier = 4,
    /// NOTE: Requires additional communication between provider and implementer.
    CustomInterpolationType = 5,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct Orientation {
    /// Frame of this orientation, with center and orientation
    #[prost(message, optional, tag = "1")]
    pub frame: ::core::option::Option<Frame>,
    /// A start time of all of the states, discrete or interpolated.
    #[prost(message, optional, tag = "2")]
    pub start_epoch: ::core::option::Option<Epoch>,
    #[prost(message, optional, tag = "3")]
    pub records: ::core::option::Option<AttitudeRegistry>,
    #[prost(message, optional, tag = "4")]
    pub interpolator: ::core::option::Option<AttitudeInterp>,
    /// A map of constant name to constant value and unit.
    #[prost(map = "string, message", tag = "5")]
    pub constants: ::std::collections::HashMap<prost::alloc::string::String, Constant>,
    /// Child orientations
    #[prost(message, repeated, tag = "6")]
    pub children: prost::alloc::vec::Vec<Orientation>,
}
/// An AttitudeRegistry contains a quickly searchable registry attitude records.
///
/// An AttitudeRegistry should be used to communicate historical data, e.g.
/// instrument X had attitude A at time T with angular velocity W and covariance
/// C. It may also be used to communicate a future desired attitude state, e.g.
/// instrument X should have attitude A at future time T with angular velocity W
/// and within accuracy covariance C all while tracking (or maintaining) the same
/// attitude / angular velocity / both.
#[derive(Clone, PartialEq, prost::Message)]
pub struct AttitudeRegistry {
    /// A pre-sorted list of all of the times (in seconds) available in the map of
    /// states. These time entries are seconds past the start_epoch provided in the
    /// higher struct. Perform a binary search in this index to retrieve time key
    /// for the desired time. In other words, search for the closest time to the
    /// desired time, and retrive the Attitude for this time. Check the repr enum
    /// to understand the attitude representation. If it isn't set, check the
    /// comments or discuss with the publisher of the file.
    ///
    /// NOTE: This provides an O(log(n)) + O(1) access to all of the states. The
    /// O(log(n)) corresponds to the binary search in the index, which then leads
    /// to an O(1) access.
    ///
    /// NOTE: Limitations of protobufs require this index to be an integer.
    /// NOTE: For better platform support, these reference times are limited to 32
    /// bits.
    #[prost(uint32, repeated, tag = "1")]
    pub time_index: prost::alloc::vec::Vec<u32>,
    /// A map associating each time (in seconds) from the index with an Attitude.
    #[prost(map = "uint32, message", tag = "2")]
    pub states: ::std::collections::HashMap<u32, Attitude>,
}
/// Nested message and enum types in `AttitudeRegistry`.
pub mod attitude_registry {
    #[derive(Clone, PartialEq, prost::Message)]
    pub struct AttitudeState {
        /// Absolute epoch
        #[prost(message, optional, tag = "1")]
        pub epoch: ::core::option::Option<super::Epoch>,
        /// The attitude itself
        #[prost(message, optional, tag = "2")]
        pub attitude: ::core::option::Option<super::Attitude>,
        /// The angular velocity, may be unspecified.
        #[prost(message, optional, tag = "3")]
        pub velocity: ::core::option::Option<super::Vector>,
        /// A disambiguation flag specifying whether the velocity is defined.
        /// Defaults to false (i.e vector is indeed defined and should be used).
        #[prost(bool, tag = "4")]
        pub velocity_is_zero: bool,
        /// The covariance array should form a matrix whose diagonal size is either 3
        /// or 4 elements of attitude (depending on its representation) plus 3
        /// elements corresponding to the angular velocity.
        #[prost(double, repeated, tag = "5")]
        pub covariance: prost::alloc::vec::Vec<f64>,
        /// The covariance exponent specifies an optional exponent for all of the
        /// components of the covariance. This enables storing high precision
        /// covariance while not losing precision of floating point values.
        #[prost(double, tag = "6")]
        pub covariance_exponent: f64,
        /// Tracking information to specify whether the spacecraft should be tracking
        /// the quaternion, the angular velocity, or both.
        #[prost(enumeration = "Tracking", tag = "7")]
        pub track: i32,
        /// An optional map of parameters associated to this state
        #[prost(map = "string, message", tag = "8")]
        pub constants: ::std::collections::HashMap<prost::alloc::string::String, super::Constant>,
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, prost::Enumeration)]
    #[repr(i32)]
    pub enum Tracking {
        /// Defaults to None, which should also be used for
        /// historical data (to communicate the attitude of an instrument when a
        /// measurement was taken for example).
        None = 0,
        TrkAttitude = 1,
        TrkVelocity = 2,
        Both = 3,
    }
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct Attitude {
    /// The attitude representation (defaults to unspecified with None as a
    /// representation).
    #[prost(enumeration = "AttitudeRepr", tag = "1")]
    pub repr: i32,
    // Note: although attitude and equations can BOTH be set, only one _should_ be
    // set. If both are set, only the attitude will be used, not the equations.
    // A limitation of protobufs prevents the structure from enforcing either/or
    // in the case of a repeated field.
    /// Exact attitude as an array whose size depends on the
    /// representation (e.g. 4 for a quaternion, 3 for an MRP).
    #[prost(double, repeated, tag = "2")]
    pub attitude: prost::alloc::vec::Vec<f64>,
    /// A list of equations to compute the attitude whose default context include
    /// `T` as centuries pas J2000 TDB and `d` as days past J2000 TDB.
    #[prost(message, repeated, tag = "3")]
    pub equations: prost::alloc::vec::Vec<Equation>,
}
/// An AttitudeInterp contains a set of a continuous attitude information.
///
/// It should be used to communicate a specific attitude and angular velocity a
/// spacecraft should maintain between two different times. It may be used to
/// store attitude estimates for historical data as well.
#[derive(Clone, PartialEq, prost::Message)]
pub struct AttitudeInterp {
    /// Type of interpolation used
    #[prost(enumeration = "InterpType", tag = "1")]
    pub itype: i32,
    /// The attitude representation (defaults to unspecified with None as a
    /// representation).
    #[prost(enumeration = "AttitudeRepr", tag = "2")]
    pub repr: i32,
    /// Degree of the interpolation used for computing the attitude (e.g. Piecewise
    /// Linear would have a degree 1, but a Hermite interpolation would usually
    /// have 2*nval - 1 where nval corresponds to the number of states used to
    /// compute the interpolation coefficients).
    #[prost(uint32, tag = "3")]
    pub attitude_degree: u32,
    /// Degree of the interpolation used for computing the velocity. Only used if
    /// the interpolation includes the velocity data.
    #[prost(uint32, tag = "4")]
    pub angular_velocity_degree: u32,
    /// A pre-sorted list of all of the times (in seconds) available in the map of
    /// interpolated states. These time entries are seconds past the
    /// start_mod_julian dates (which is in days). Perform a binary search in this
    /// index to retrieve time key for the desired time. In other words, search for
    /// the closest time to the desired time, retrive the InterpState for this
    /// time, build the interpolation functions, and finally apply these at the
    /// desired time.
    ///
    /// NOTE: This provides an O(log(n)) + O(1) access to all of the states. The
    /// O(log(n)) corresponds to the binary search in the index, which then leads
    /// to an O(1) access. NOTE: Only variable size (or "unequally spaced") windows
    /// are supported. Attitude information is usually provided for short-enough
    /// periods of time that equally spaced interpolations do not add significant
    /// value. One may always use these states as equally spaced windows. NOTE:
    /// Limitations of protobufs require this index to be an integer. NOTE: For
    /// better platform support, these reference times are limited to 32 bits.
    #[prost(uint32, repeated, tag = "5")]
    pub time_index_s: prost::alloc::vec::Vec<u32>,
    /// A map associating each time (in seconds) from the index with an
    /// InterpState.
    #[prost(map = "uint32, message", tag = "6")]
    pub states: ::std::collections::HashMap<u32, attitude_interp::InterpState>,
    /// The minimum value of the time input to the interpolation function (usually
    /// -1 for Chebyshev and Hermite interpolations)
    #[prost(double, tag = "7")]
    pub time_normalization_min: f64,
    /// The maxmum value of the time input to the interpolation function (usually
    /// +1 for Chebyshev and Hermite interpolations)
    #[prost(double, tag = "8")]
    pub time_normalization_max: f64,
}
/// Nested message and enum types in `AttitudeInterp`.
pub mod attitude_interp {
    /// These coefficients should be computed through an interpolation where the
    /// time data is aligned between 0 and 1, unless noted otherwise.
    #[derive(Clone, PartialEq, prost::Message)]
    pub struct InterpState {
        /// Relative time in seconds compared to the indexed time.
        #[prost(double, tag = "1")]
        pub time_offset_s: f64,
        /// Duration in seconds for which these states are valid.
        #[prost(float, tag = "2")]
        pub window_duration: f32,
        /// Unit of the window duration. If unset, assume seconds!
        #[prost(enumeration = "super::Unit", tag = "3")]
        pub time_unit: i32,
        /// All angular velocity coefficients for this time offset.
        #[prost(message, optional, tag = "6")]
        pub angular_velocity: ::core::option::Option<super::VectorCoefficients>,
        #[prost(oneof = "interp_state::Attitude", tags = "4, 5")]
        pub attitude: ::core::option::Option<interp_state::Attitude>,
    }
    /// Nested message and enum types in `InterpState`.
    pub mod interp_state {
        #[derive(Clone, PartialEq, prost::Oneof)]
        pub enum Attitude {
            /// Attitude interpolation can be as quaternion
            #[prost(message, tag = "4")]
            Dim4(super::super::QuaternionCoefficients),
            /// Or as dimension 3 (CRP, MRP, Euler angles, etc.)
            #[prost(message, tag = "5")]
            Dim3(super::super::VectorCoefficients),
        }
    }
}
/// Used to store quaternion coefficients to interpolate.
#[derive(Clone, PartialEq, prost::Message)]
pub struct QuaternionCoefficients {
    #[prost(double, repeated, tag = "1")]
    pub q0: prost::alloc::vec::Vec<f64>,
    #[prost(double, repeated, tag = "2")]
    pub q1: prost::alloc::vec::Vec<f64>,
    #[prost(double, repeated, tag = "3")]
    pub q2: prost::alloc::vec::Vec<f64>,
    #[prost(double, repeated, tag = "4")]
    pub q3: prost::alloc::vec::Vec<f64>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, prost::Enumeration)]
#[repr(i32)]
pub enum AttitudeRepr {
    NotApplicable = 0,
    /// Quaternion where the leading item is the scalar
    QuaternionLead = 1,
    /// Quaternion where the trailing item is the scalar
    QuaternionTrail = 2,
    /// Euler representations
    Euler121 = 3,
    Euler123 = 4,
    Euler131 = 5,
    Euler132 = 6,
    Euler212 = 7,
    Euler213 = 8,
    Euler231 = 9,
    Euler232 = 10,
    Euler312 = 11,
    Euler313 = 12,
    Euler321 = 13,
    Euler323 = 14,
    /// Classical Rodriguez parameters
    Crp = 15,
    /// Modified Rodriguez parameters
    Mrp = 16,
    /// Right ascension / declination / prime meridian location (W)
    RaDecW = 17,
    /// Representation should be specified in the file or ICD
    CustomAttRepr = 18,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct Ephemeris {
    /// Nmae of this ephemeris
    #[prost(string, tag = "1")]
    pub name: prost::alloc::string::String,
    /// Name of the orientation frame
    #[prost(string, tag = "2")]
    pub orientation: prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub start_epoch: ::core::option::Option<Epoch>,
    /// A registry of states without interpolation.
    #[prost(message, optional, tag = "4")]
    pub records: ::core::option::Option<EphemRegistry>,
    #[prost(message, optional, tag = "5")]
    pub interpolator: ::core::option::Option<EphemInterp>,
    /// A map of constant name to constant value and unit.
    #[prost(map = "string, message", tag = "6")]
    pub constants: ::std::collections::HashMap<prost::alloc::string::String, Constant>,
    /// A map of gravity fields available
    #[prost(map = "string, message", tag = "7")]
    pub harmonics: ::std::collections::HashMap<prost::alloc::string::String, GravityField>,
    /// Child ephemerides, ordered from closest to the parent to furthest
    #[prost(message, repeated, tag = "8")]
    pub children: prost::alloc::vec::Vec<Ephemeris>,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct EphemRegistry {
    #[prost(message, repeated, tag = "1")]
    pub states: prost::alloc::vec::Vec<State>,
    #[prost(enumeration = "Unit", tag = "2")]
    pub distance_unit: i32,
    #[prost(enumeration = "Unit", tag = "3")]
    pub velocity_unit: i32,
    /// Frame of these states, useful for reusability
    #[prost(message, optional, tag = "4")]
    pub frame: ::core::option::Option<Frame>,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct State {
    /// Absolute epoch
    #[prost(message, optional, tag = "1")]
    pub epoch: ::core::option::Option<Epoch>,
    /// The position may be unset, check the is_zero flag of the Vector.
    #[prost(message, optional, tag = "2")]
    pub position: ::core::option::Option<Vector>,
    /// The velocity may be unset, check the is_zero flag of the Vector.
    #[prost(message, optional, tag = "3")]
    pub velocity: ::core::option::Option<Vector>,
    /// If the covariance is composed entirely of zeros, it is not informative,
    /// and therefore can be assumed to be unset.
    #[prost(message, optional, tag = "4")]
    pub covariance: ::core::option::Option<state::Covariance>,
    /// The covariance exponent specifies an optional exponent for all of the
    /// components of the covariance. This enables storing high precision
    /// covariance while not losing precision of floating point values.
    #[prost(double, tag = "5")]
    pub covariance_exponent: f64,
    /// A map of constants associated with this state
    #[prost(map = "string, message", tag = "6")]
    pub constants: ::std::collections::HashMap<prost::alloc::string::String, Constant>,
}
/// Nested message and enum types in `State`.
pub mod state {
    #[derive(Clone, PartialEq, prost::Message)]
    pub struct Covariance {
        /// The Covariance of the object is based on the CCSDS OEM Data format.
        ///
        /// Covariance matrix [1,1]
        #[prost(double, tag = "1")]
        pub cx_x: f64,
        /// Covariance matrix [2,1]
        #[prost(double, tag = "2")]
        pub cy_x: f64,
        /// Covariance matrix [2,2]
        #[prost(double, tag = "3")]
        pub cy_y: f64,
        /// Covariance matrix [3,1]
        #[prost(double, tag = "4")]
        pub cz_x: f64,
        /// Covariance matrix [3,2]
        #[prost(double, tag = "5")]
        pub cz_y: f64,
        /// Covariance matrix [3,3]
        #[prost(double, tag = "6")]
        pub cz_z: f64,
        /// Covariance matrix [4,1]
        #[prost(double, tag = "7")]
        pub cx_dot_x: f64,
        /// Covariance matrix [4,2]
        #[prost(double, tag = "8")]
        pub cx_dot_y: f64,
        /// Covariance matrix [4,3]
        #[prost(double, tag = "9")]
        pub cx_dot_z: f64,
        /// Covariance matrix [4,4]
        #[prost(double, tag = "10")]
        pub cx_dot_x_dot: f64,
        /// Covariance matrix [5,1]
        #[prost(double, tag = "11")]
        pub cy_dot_x: f64,
        /// Covariance matrix [5,2]
        #[prost(double, tag = "12")]
        pub cy_dot_y: f64,
        /// Covariance matrix [5,3]
        #[prost(double, tag = "13")]
        pub cy_dot_z: f64,
        /// Covariance matrix [5,4]
        #[prost(double, tag = "14")]
        pub cy_dot_x_dot: f64,
        /// Covariance matrix [5,5]
        #[prost(double, tag = "15")]
        pub cy_dot_y_dot: f64,
        /// Covariance matrix [6,1]
        #[prost(double, tag = "16")]
        pub cz_dot_x: f64,
        /// Covariance matrix [6,2]
        #[prost(double, tag = "17")]
        pub cz_dot_y: f64,
        /// Covariance matrix [6,3]
        #[prost(double, tag = "18")]
        pub cz_dot_z: f64,
        /// Covariance matrix [6,4]
        #[prost(double, tag = "19")]
        pub cz_dot_x_dot: f64,
        /// Covariance matrix [6,5]
        #[prost(double, tag = "20")]
        pub cz_dot_y_dot: f64,
        /// Covariance matrix [6,6]
        #[prost(double, tag = "21")]
        pub cz_dot_z_dot: f64,
    }
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct EphemInterp {
    /// Type of interpolation used
    #[prost(enumeration = "InterpType", tag = "1")]
    pub itype: i32,
    /// Degree of the interpolation used for computing the position (e.g. Piecewise
    /// Linear would have a degree 1, but a Hermite interpolation would usually
    /// have 2*nval - 1 where nval corresponds to the number of states used to
    /// compute the interpolation coefficients).
    #[prost(uint32, tag = "2")]
    pub position_degree: u32,
    /// Degree of the interpolation used for computing the velocity. Only used if
    /// the interpolation includes the velocity data.
    #[prost(uint32, tag = "3")]
    pub velocity_degree: u32,
    #[prost(enumeration = "Unit", tag = "6")]
    pub distance_unit: i32,
    #[prost(enumeration = "Unit", tag = "7")]
    pub velocity_unit: i32,
    #[prost(oneof = "ephem_interp::StateData", tags = "4, 5")]
    pub state_data: ::core::option::Option<ephem_interp::StateData>,
}
/// Nested message and enum types in `EphemInterp`.
pub mod ephem_interp {
    #[derive(Clone, PartialEq, prost::Oneof)]
    pub enum StateData {
        #[prost(message, tag = "4")]
        EqualStates(super::EqualStepStates),
        #[prost(message, tag = "5")]
        VarwindowStates(super::VarWindowStates),
    }
}
/// EqualStepStates provides an O(1) access to all of the states.
/// To access state of time T, get the index as
/// floor((t_in_mod_julian - epoch_mod_julian)/window_duration) .
/// This state's coefficients can be cached for quicker continuous computation.
/// Note that we store the position and velocity outside of a message for smaller
/// serialized structure (two contiguous lists of structures).
#[derive(Clone, PartialEq, prost::Message)]
pub struct EqualStepStates {
    /// Fixed window duration for all of the states (unit specified below, or
    /// assume days)
    #[prost(double, tag = "1")]
    pub window_duration: f64,
    /// Unit of the window duration (is typically days)
    #[prost(enumeration = "Unit", tag = "2")]
    pub window_duration_unit: i32,
    /// All position coefficients for this time offset.
    #[prost(message, repeated, tag = "3")]
    pub position: prost::alloc::vec::Vec<VectorCoefficients>,
    /// All velocity coefficients for this time offset. Optional, but if used, it
    /// **must** be of the same length as the list of position coefficients.
    #[prost(message, repeated, tag = "4")]
    pub velocity: prost::alloc::vec::Vec<VectorCoefficients>,
}
/// VarWindowStates provides an O(log(n)) + O(1) access to all of the states. The
/// O(log(n))
/// corresponds to the binary search in the index, which then leads to an O(1)
/// access.
#[derive(Clone, PartialEq, prost::Message)]
pub struct VarWindowStates {
    /// A pre-sorted list of all of the times (in seconds) available in the map of
    /// interpolated states. These time entries are seconds past the start_epoch
    /// (defined in the parent Ephemeris object). Perform a binary search in this
    /// index to retrieve time key for the desired time. In other words, search for
    /// the closest time to the desired time, retrive the InterpState for this
    /// time, build the interpolation functions, and finally apply these at the
    /// desired time. NOTE: Limitations of protobufs require this index to be an
    /// integer. NOTE: For better platform support, these reference times are
    /// limited to 32 bits.
    #[prost(uint32, repeated, tag = "1")]
    pub time_index_s: prost::alloc::vec::Vec<u32>,
    /// A map associating each time (in seconds) from the index with a InterpState.
    #[prost(map = "uint32, message", tag = "2")]
    pub interp_states: ::std::collections::HashMap<u32, var_window_states::InterpState>,
    /// The minimum value of the time input to the interpolation function (usually
    /// -1 for Chebyshev and Hermite interpolations)
    #[prost(double, tag = "3")]
    pub time_normalization_min: f64,
    /// The maxmum value of the time input to the interpolation function (usually
    /// +1 for Chebyshev and Hermite interpolations)
    #[prost(double, tag = "4")]
    pub time_normalization_max: f64,
}
/// Nested message and enum types in `VarWindowStates`.
pub mod var_window_states {
    /// These coefficients should be computed through an interpolation where the
    /// time data is aligned between 0 and 1, unless noted otherwise.
    #[derive(Clone, PartialEq, prost::Message)]
    pub struct InterpState {
        /// Relative time compared to the indexed time (in seconds). Add this to the
        /// indexed time to compute the relative epoch of the start of this window
        #[prost(double, tag = "1")]
        pub time_offset_s: f64,
        /// Duration of the window: used to compute the inverse interpolant
        #[prost(double, tag = "2")]
        pub window_duration: f64,
        /// Unit of the window duration. If unset, assume seconds!
        #[prost(enumeration = "super::Unit", tag = "3")]
        pub time_unit: i32,
        /// All position coefficients for this time offset.
        #[prost(message, optional, tag = "4")]
        pub position: ::core::option::Option<super::VectorCoefficients>,
        /// All velocity coefficients for this time offset.
        #[prost(message, optional, tag = "5")]
        pub velocity: ::core::option::Option<super::VectorCoefficients>,
    }
}
/// Structure of the gravity field is based on information from
/// https://earth-info.nga.mil/GandG/wgs84/gravitymod/egm2008/README_WGS84_2.pdf
#[derive(Clone, PartialEq, prost::Message)]
pub struct GravityField {
    /// Frame in which this gravity field applies, with center and orientation
    #[prost(message, optional, tag = "1")]
    pub frame: ::core::option::Option<Frame>,
    /// For example, the Earth gravity fields typically start at degree 2
    #[prost(uint32, tag = "2")]
    pub min_degree: u32,
    /// For example, as 70x70 gravity field would set the max_degree to 70
    #[prost(uint32, tag = "3")]
    pub max_degree: u32,
    /// The order always starts at zero, hence there is no min_order
    #[prost(uint32, tag = "4")]
    pub max_order: u32,
    /// The spherical harmonic coefficients. This array must be rebuilt as a
    /// matrix using the degree and order defined above.
    #[prost(double, repeated, tag = "5")]
    pub c_nm: prost::alloc::vec::Vec<f64>,
    #[prost(double, repeated, tag = "6")]
    pub s_nm: prost::alloc::vec::Vec<f64>,
    /// The associated error standard deviations. This array must be rebuilt as a
    /// matrix using the degree and order defined above.
    #[prost(double, repeated, tag = "7")]
    pub sigma_c_nm: prost::alloc::vec::Vec<f64>,
    #[prost(double, repeated, tag = "8")]
    pub sigma_s_nm: prost::alloc::vec::Vec<f64>,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct Instrument {
    /// Frame should contain the full path to this instrument
    #[prost(message, optional, tag = "1")]
    pub frame: ::core::option::Option<Frame>,
    /// The position offset from the parent frame
    #[prost(message, optional, tag = "2")]
    pub position_offset: ::core::option::Option<Vector>,
    /// The orientation offset from the parent frame
    #[prost(message, optional, tag = "3")]
    pub orientation_offset: ::core::option::Option<Attitude>,
    #[prost(map = "string, message", tag = "4")]
    pub constants: ::std::collections::HashMap<prost::alloc::string::String, Constant>,
    /// Child instruments
    #[prost(message, repeated, tag = "5")]
    pub children: prost::alloc::vec::Vec<Instrument>,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct NavigationObject {
    /// Identifier of the object
    #[prost(string, tag = "1")]
    pub object: prost::alloc::string::String,
    /// Observer frame which include its center and orientation (e.g. "DSS
    /// 65" and "IAU Earth").
    #[prost(message, optional, tag = "2")]
    pub observer: ::core::option::Option<Frame>,
    /// A list of tracking passes for this object
    #[prost(message, repeated, tag = "3")]
    pub passes: prost::alloc::vec::Vec<TrackingPass>,
    /// A map of constants of that object applicable to all tracking passes.
    #[prost(map = "string, message", tag = "5")]
    pub constants: ::std::collections::HashMap<prost::alloc::string::String, Constant>,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct TrackingPass {
    /// Unique identifier of the navigation data
    #[prost(string, tag = "1")]
    pub pass_uid: prost::alloc::string::String,
    /// Start epoch of the tracking pass
    #[prost(message, optional, tag = "2")]
    pub start_epoch: ::core::option::Option<Epoch>,
    /// End epoch of the tracking pass
    #[prost(message, optional, tag = "3")]
    pub end_epoch: ::core::option::Option<Epoch>,
    /// Actual observations
    #[prost(message, repeated, tag = "4")]
    pub obs: prost::alloc::vec::Vec<Observation>,
    /// An optional set of solutions
    #[prost(message, optional, tag = "5")]
    pub sol: ::core::option::Option<NavSolutions>,
    /// An optional map of parameter name to parameter value and unit.
    #[prost(map = "string, message", tag = "6")]
    pub constants: ::std::collections::HashMap<prost::alloc::string::String, Constant>,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct Observation {
    /// Absolute epoch
    #[prost(message, optional, tag = "1")]
    pub epoch: ::core::option::Option<Epoch>,
    /// The observation itself
    #[prost(double, tag = "2")]
    pub obs: f64,
    /// Kind of observation
    #[prost(enumeration = "ObsKind", tag = "3")]
    pub kind: i32,
    /// Unit of the observation
    #[prost(enumeration = "Unit", tag = "4")]
    pub unit: i32,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct NavSolutions {
    /// A registry of states without interpolation.
    #[prost(message, optional, tag = "1")]
    pub state_reg: ::core::option::Option<EphemRegistry>,
    /// Stores the residuals. If the filter processes several observations at the
    /// same time (e.g. Range and Range-Rate), then it is recommended that two
    /// entries we added to this list both with the same epoch.
    #[prost(message, repeated, tag = "2")]
    pub residuals: prost::alloc::vec::Vec<Residual>,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct Residual {
    /// Absolute epoch
    #[prost(message, optional, tag = "1")]
    pub epoch: ::core::option::Option<Epoch>,
    /// The prefit residual itself
    #[prost(double, tag = "2")]
    pub prefit: f64,
    /// The postfit residual
    #[prost(double, tag = "3")]
    pub postfit: f64,
    /// Kind of observation which resulted in this set of residuals
    #[prost(enumeration = "ObsKind", tag = "4")]
    pub obskind: i32,
    /// Unit of the residual
    #[prost(enumeration = "Unit", tag = "5")]
    pub unit: i32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, prost::Enumeration)]
#[repr(i32)]
pub enum ObsKind {
    /// In distance units
    Range = 0,
    /// In velocity units
    RangeRate = 1,
    /// In frequency units
    Doppler = 2,
    /// Dimensionless
    RangeUnits = 3,
    /// In angle units
    Angles = 4,
    /// In angular rate units
    AngluarRate = 5,
    /// Valid only for residual
    None = 10,
    Custom = 11,
}
#[derive(Clone, PartialEq, prost::Message)]
pub struct Xb {
    #[prost(message, optional, tag = "1")]
    pub meta: ::core::option::Option<Metadata>,
    #[prost(map = "string, message", tag = "2")]
    pub constants: ::std::collections::HashMap<prost::alloc::string::String, Constant>,
    #[prost(message, optional, tag = "3")]
    pub ephemeris_root: ::core::option::Option<Ephemeris>,
    #[prost(message, optional, tag = "4")]
    pub orientation_root: ::core::option::Option<Orientation>,
    #[prost(message, repeated, tag = "5")]
    pub navigation_objects: prost::alloc::vec::Vec<NavigationObject>,
    #[prost(message, optional, tag = "6")]
    pub instrument_root: ::core::option::Option<Instrument>,
}