"""This file was generated by xsdata, v26.1, on 2026-02-18 00:41:07

Generator: DataclassGenerator
See: https://xsdata.readthedocs.io/
"""

from __future__ import annotations

from dataclasses import dataclass, field
from enum import Enum

__NAMESPACE__ = "urn:ccsds:schema:ndmxml"


class AccUnits(Enum):
    KM_S_2 = "km/s**2"


class AcmAttitudeType(Enum):
    QUATERNION = "QUATERNION"
    QUATERNION_1 = "quaternion"
    EULER_ANGLES = "EULER_ANGLES"
    EULER_ANGLES_1 = "euler_angles"
    DCM = "DCM"
    DCM_1 = "dcm"
    ANGVEL = "ANGVEL"
    ANGVEL_1 = "angvel"
    Q_DOT = "Q_DOT"
    Q_DOT_1 = "q_dot"
    EULER_RATE = "EULER_RATE"
    EULER_RATE_1 = "euler_rate"
    GYRO_BIAS = "GYRO_BIAS"
    GYRO_BIAS_1 = "gyro_bias"


class AcmCovarianceLineType(Enum):
    ANGLE = "ANGLE"
    ANGLE_1 = "angle"
    ANGLE_GYROBIAS = "ANGLE_GYROBIAS"
    ANGLE_GYROBIAS_1 = "angle_gyrobias"
    ANGLE_ANGVEL = "ANGLE_ANGVEL"
    ANGLE_ANGVEL_1 = "angle_angvel"
    QUATERNION = "QUATERNION"
    QUATERNION_1 = "quaternion"
    QUATERNION_GYROBIAS = "QUATERNION_GYROBIAS"
    QUATERNION_GYROBIAS_1 = "quaternion_gyrobias"
    QUATERNION_ANGVEL = "QUATERNION_ANGVEL"
    QUATERNION_ANGVEL_1 = "quaternion_angvel"


class AdMethodType(Enum):
    EKF = "EKF"
    EKF_1 = "ekf"
    TRIAD = "TRIAD"
    TRIAD_1 = "triad"
    QUEST = "QUEST"
    QUEST_1 = "quest"
    BATCH = "BATCH"
    BATCH_1 = "batch"
    Q_METHOD = "Q_METHOD"
    Q_METHOD_1 = "q_method"
    FILTER_SMOOTHER = "FILTER_SMOOTHER"
    FILTER_SMOOTHER_1 = "filter_smoother"
    OTHER = "OTHER"
    OTHER_1 = "other"


@dataclass(kw_only=True)
class AdmHeader:
    class Meta:
        name = "admHeader"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    classification: None | str = field(
        default=None,
        metadata={
            "name": "CLASSIFICATION",
            "type": "Element",
            "namespace": "",
        },
    )
    creation_date: str = field(
        metadata={
            "name": "CREATION_DATE",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    originator: str = field(
        metadata={
            "name": "ORIGINATOR",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    message_id: None | str = field(
        default=None,
        metadata={
            "name": "MESSAGE_ID",
            "type": "Element",
            "namespace": "",
        },
    )


class AngMomentumUnits(Enum):
    N_M_S = "N*m*s"


class AngleRateUnits(Enum):
    DEG_S = "deg/s"


class AngleUnits(Enum):
    DEG = "deg"


class AreaUnits(Enum):
    M_2 = "m**2"


class AttBasisType(Enum):
    PREDICTED = "PREDICTED"
    PREDICTED_1 = "predicted"
    DETERMINED_GND = "DETERMINED_GND"
    DETERMINED_GND_1 = "determined_gnd"
    DETERMINED_OBC = "DETERMINED_OBC"
    DETERMINED_OBC_1 = "determined_obc"
    SIMULATED = "SIMULATED"
    SIMULATED_1 = "simulated"


class AttRateType(Enum):
    ANGVEL = "ANGVEL"
    ANGVEL_1 = "angvel"
    Q_DOT = "Q_DOT"
    Q_DOT_1 = "q_dot"
    EULER_RATE = "EULER_RATE"
    EULER_RATE_1 = "euler_rate"
    GYRO_BIAS = "GYRO_BIAS"
    GYRO_BIAS_1 = "gyro_bias"


class AttitudeTypeType(Enum):
    QUATERNION = "quaternion"
    QUATERNION_1 = "QUATERNION"
    QUATERNION_DERIVATIVE = "quaternion/derivative"
    QUATERNION_DERIVATIVE_1 = "QUATERNION/DERIVATIVE"
    QUATERNION_ANGVEL = "quaternion/angvel"
    QUATERNION_ANGVEL_1 = "QUATERNION/ANGVEL"
    EULER_ANGLE = "euler_angle"
    EULER_ANGLE_1 = "EULER_ANGLE"
    EULER_ANGLE_DERIVATIVE = "euler_angle/derivative"
    EULER_ANGLE_DERIVATIVE_1 = "EULER_ANGLE/DERIVATIVE"
    EULER_ANGLE_ANGVEL = "euler_angle/angvel"
    EULER_ANGLE_ANGVEL_1 = "EULER_ANGLE/ANGVEL"
    SPIN = "spin"
    SPIN_1 = "SPIN"
    SPIN_NUTATION = "spin/nutation"
    SPIN_NUTATION_1 = "SPIN/NUTATION"
    SPIN_NUTATION_MOM = "spin/nutation_mom"
    SPIN_NUTATION_MOM_1 = "SPIN/NUTATION_MOM"


class BallisticCoeffUnitsType(Enum):
    KG_M_2 = "kg/m**2"


class ControlledType(Enum):
    YES = "YES"
    YES_1 = "yes"
    NO = "NO"
    NO_1 = "no"
    UNKNOWN = "UNKNOWN"
    UNKNOWN_1 = "unknown"


class CovBasisType(Enum):
    PREDICTED = "PREDICTED"
    DETERMINED = "DETERMINED"
    EMPIRICAL = "EMPIRICAL"
    SIMULATED = "SIMULATED"
    OTHER = "OTHER"


class CovOrderType(Enum):
    LTM = "LTM"
    UTM = "UTM"
    FULL = "FULL"
    LTMWCC = "LTMWCC"
    UTMWCC = "UTMWCC"


class DayIntervalUnits(Enum):
    D = "d"


class DisintegrationType(Enum):
    NONE = "NONE"
    MASS_LOSS = "MASS-LOSS"
    BREAK_UP = "BREAK-UP"
    MASS_LOSS_BREAK_UP = "MASS-LOSS + BREAK-UP"


class FrequencyUnits(Enum):
    HZ = "Hz"


class GeomagUnits(Enum):
    N_T = "nT"


class GmUnits(Enum):
    KM_3_S_2 = "km**3/s**2"
    KM_3_S_2_1 = "KM**3/S**2"


class ImpactUncertaintyType(Enum):
    NONE = "NONE"
    ANALYTICAL = "ANALYTICAL"
    STOCHASTIC = "STOCHASTIC"
    EMPIRICAL = "EMPIRICAL"


class Km2Units(Enum):
    KM_2 = "km**2"


class Km2S2Units(Enum):
    KM_2_S_2 = "km**2/s**2"


class Km2SUnits(Enum):
    KM_2_S = "km**2/s"


class LatLonUnits(Enum):
    DEG = "deg"


class LengthUnits(Enum):
    M = "m"


class ManBasisType(Enum):
    CANDIDATE = "CANDIDATE"
    PLANNED = "PLANNED"
    ANTICIPATED = "ANTICIPATED"
    TELEMETRY = "TELEMETRY"
    DETERMINED = "DETERMINED"
    SIMULATED = "SIMULATED"
    OTHER = "OTHER"


class ManDctype(Enum):
    CONTINUOUS = "CONTINUOUS"
    TIME = "TIME"
    TIME_AND_ANGLE = "TIME_AND_ANGLE"


class MassUnits(Enum):
    KG = "kg"


class MomentUnits(Enum):
    KG_M_2 = "kg*m**2"


class Ms2Units(Enum):
    M_S_2 = "m/s**2"


@dataclass(kw_only=True)
class NdmHeader:
    class Meta:
        name = "ndmHeader"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    creation_date: str = field(
        metadata={
            "name": "CREATION_DATE",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    originator: str = field(
        metadata={
            "name": "ORIGINATOR",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


class NumPerYearUnits(Enum):
    YR = "#/yr"


class ObjectDescriptionType(Enum):
    PAYLOAD = "PAYLOAD"
    PAYLOAD_1 = "payload"
    ROCKET_BODY = "ROCKET BODY"
    ROCKET_BODY_1 = "rocket body"
    DEBRIS = "DEBRIS"
    DEBRIS_1 = "debris"
    UNKNOWN = "UNKNOWN"
    UNKNOWN_1 = "unknown"
    OTHER = "OTHER"
    OTHER_1 = "other"


@dataclass(kw_only=True)
class OdmHeader:
    class Meta:
        name = "odmHeader"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    classification: None | str = field(
        default=None,
        metadata={
            "name": "CLASSIFICATION",
            "type": "Element",
            "namespace": "",
        },
    )
    creation_date: str = field(
        metadata={
            "name": "CREATION_DATE",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    originator: str = field(
        metadata={
            "name": "ORIGINATOR",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    message_id: None | str = field(
        default=None,
        metadata={
            "name": "MESSAGE_ID",
            "type": "Element",
            "namespace": "",
        },
    )


@dataclass(kw_only=True)
class OemCovarianceMatrixAbstractType:
    class Meta:
        name = "oemCovarianceMatrixAbstractType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    epoch: str = field(
        metadata={
            "name": "EPOCH",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    cov_ref_frame: None | str = field(
        default=None,
        metadata={
            "name": "COV_REF_FRAME",
            "type": "Element",
            "namespace": "",
        },
    )


@dataclass(kw_only=True)
class OpmCovarianceMatrixAbstractType:
    class Meta:
        name = "opmCovarianceMatrixAbstractType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    cov_ref_frame: None | str = field(
        default=None,
        metadata={
            "name": "COV_REF_FRAME",
            "type": "Element",
            "namespace": "",
        },
    )


class PercentageUnits(Enum):
    PERCENT_SIGN = "%"


class PositionCovarianceUnits(Enum):
    KM_2 = "km**2"


class PositionUnits(Enum):
    KM = "km"


class PositionVelocityCovarianceUnits(Enum):
    KM_2_S = "km**2/s"


class QuaternionDotUnits(Enum):
    VALUE_1_S = "1/s"


@dataclass(kw_only=True)
class QuaternionType:
    class Meta:
        name = "quaternionType"

    q1: float = field(
        metadata={
            "name": "Q1",
            "type": "Element",
            "namespace": "",
            "required": True,
            "min_inclusive": -1.0,
            "max_inclusive": 1.0,
        }
    )
    q2: float = field(
        metadata={
            "name": "Q2",
            "type": "Element",
            "namespace": "",
            "required": True,
            "min_inclusive": -1.0,
            "max_inclusive": 1.0,
        }
    )
    q3: float = field(
        metadata={
            "name": "Q3",
            "type": "Element",
            "namespace": "",
            "required": True,
            "min_inclusive": -1.0,
            "max_inclusive": 1.0,
        }
    )
    qc: float = field(
        metadata={
            "name": "QC",
            "type": "Element",
            "namespace": "",
            "required": True,
            "min_inclusive": -1.0,
            "max_inclusive": 1.0,
        }
    )


class ReentryUncertaintyMethodType(Enum):
    NONE = "NONE"
    ANALYTICAL = "ANALYTICAL"
    STOCHASTIC = "STOCHASTIC"
    EMPIRICAL = "EMPIRICAL"


class RevNumBasisType(Enum):
    VALUE_0 = 0
    VALUE_1 = 1


class RotseqType(Enum):
    XYX = "XYX"
    XYZ = "XYZ"
    XZX = "XZX"
    XZY = "XZY"
    YXY = "YXY"
    YXZ = "YXZ"
    YZX = "YZX"
    YZY = "YZY"
    ZXY = "ZXY"
    ZXZ = "ZXZ"
    ZYX = "ZYX"
    ZYZ = "ZYZ"


class SigmaUunits(Enum):
    DEG_S_1_5 = "deg/s**1.5"


class SigmaVunits(Enum):
    DEG_S_0_5 = "deg/s**0.5"


class SolarFluxUnits(Enum):
    SFU = "SFU"
    VALUE_10_4_JANSKY = "10**4 Jansky"
    VALUE_10_22_W_M_2_HZ = "10**-22 W/(m**2/Hz)"
    VALUE_10_19_ERG_S_CM_2_HZ = "10**-19 erg/(s*cm**2*Hz)"


class ThrustUnits(Enum):
    N = "N"


class TimeUnits(Enum):
    S = "s"


class TorqueUnits(Enum):
    N_M = "N*m"


class TrajBasisType(Enum):
    PREDICTED = "PREDICTED"
    DETERMINED = "DETERMINED"
    TELEMETRY = "TELEMETRY"
    SIMULATED = "SIMULATED"
    OTHER = "OTHER"


@dataclass(kw_only=True)
class UserDefinedParameterType:
    class Meta:
        name = "userDefinedParameterType"

    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    parameter: str = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )


class VelocityCovarianceUnits(Enum):
    KM_2_S_2 = "km**2/s**2"


class VelocityUnits(Enum):
    KM_S = "km/s"


class WkgUnits(Enum):
    W_KG = "W/kg"


class YesNoType(Enum):
    YES = "YES"
    YES_1 = "yes"
    NO = "NO"
    NO_1 = "no"


@dataclass(kw_only=True)
class AccType:
    class Meta:
        name = "accType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | AccUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class AltType:
    class Meta:
        name = "altType"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": -430.5,
            "max_inclusive": 8848.0,
        }
    )
    units: None | LengthUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class AngMomentumType:
    class Meta:
        name = "angMomentumType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | AngMomentumUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class AngVelComponentType:
    class Meta:
        name = "angVelComponentType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | AngleRateUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class AngleRateType:
    class Meta:
        name = "angleRateType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | AngleRateUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class AngleType:
    class Meta:
        name = "angleType"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": -360.0,
            "max_exclusive": 360.0,
        }
    )
    units: None | AngleUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class AreaType:
    class Meta:
        name = "areaType"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": 0.0,
        }
    )
    units: None | AreaUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class BallisticCoeffType:
    class Meta:
        name = "ballisticCoeffType"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": 0.0,
        }
    )
    units: None | BallisticCoeffUnitsType = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class CpType:
    class Meta:
        name = "cpType"

    value: list[float] = field(
        default_factory=list,
        metadata={
            "length": 3,
            "tokens": True,
        },
    )
    units: None | LengthUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class DayIntervalTypeUo:
    class Meta:
        name = "dayIntervalTypeUO"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": 0.0,
        }
    )
    units: None | DayIntervalUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class DayIntervalTypeUr:
    class Meta:
        name = "dayIntervalTypeUR"

    value: float = field(
        metadata={
            "required": True,
            "min_exclusive": 0.0,
        }
    )
    units: DayIntervalUnits = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class DeltamassType:
    class Meta:
        name = "deltamassType"

    value: float = field(
        metadata={
            "required": True,
            "max_exclusive": 0.0,
        }
    )
    units: None | MassUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class DeltamassTypeZ:
    class Meta:
        name = "deltamassTypeZ"

    value: float = field(
        metadata={
            "required": True,
            "max_inclusive": 0.0,
        }
    )
    units: None | MassUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class DistanceType:
    class Meta:
        name = "distanceType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | PositionUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class DurationType:
    class Meta:
        name = "durationType"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": 0.0,
        }
    )
    units: None | TimeUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class FrequencyType:
    class Meta:
        name = "frequencyType"

    value: float = field(
        metadata={
            "required": True,
            "min_exclusive": 0.0,
        }
    )
    units: None | FrequencyUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class GeomagType:
    class Meta:
        name = "geomagType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | GeomagUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class GmType:
    class Meta:
        name = "gmType"

    value: float = field(
        metadata={
            "required": True,
            "min_exclusive": 0.0,
        }
    )
    units: None | GmUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class InclinationType:
    class Meta:
        name = "inclinationType"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": 0.0,
            "max_exclusive": 360.0,
            "max_inclusive": 180.0,
        }
    )
    units: None | AngleUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class Km2Type:
    class Meta:
        name = "km2Type"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | Km2Units = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class Km2S2Type:
    class Meta:
        name = "km2s2Type"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | Km2S2Units = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class Km2SType:
    class Meta:
        name = "km2sType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | Km2SUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class LatType:
    class Meta:
        name = "latType"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": -90.0,
            "max_inclusive": 90.0,
        }
    )
    units: LatLonUnits = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class LengthTypeUo:
    class Meta:
        name = "lengthTypeUO"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | LengthUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class LengthTypeUr:
    class Meta:
        name = "lengthTypeUR"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: LengthUnits = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class LonType:
    class Meta:
        name = "lonType"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": -180.0,
            "max_inclusive": 180.0,
        }
    )
    units: LatLonUnits = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class ManeuverFreqType:
    class Meta:
        name = "maneuverFreqType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | NumPerYearUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class MassType:
    class Meta:
        name = "massType"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": 0.0,
        }
    )
    units: None | MassUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class MomentType:
    class Meta:
        name = "momentType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | MomentUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class Ms2Type:
    class Meta:
        name = "ms2Type"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: Ms2Units = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class PercentageTypeUo:
    class Meta:
        name = "percentageTypeUO"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": 0.0,
            "max_inclusive": 100.0,
        }
    )
    units: None | PercentageUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class PercentageTypeUr:
    class Meta:
        name = "percentageTypeUR"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": 0.0,
            "max_inclusive": 100.0,
        }
    )
    units: PercentageUnits = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class PositionCovarianceType:
    class Meta:
        name = "positionCovarianceType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | PositionCovarianceUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class PositionTypeUo:
    class Meta:
        name = "positionTypeUO"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | PositionUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class PositionTypeUr:
    class Meta:
        name = "positionTypeUR"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: PositionUnits = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class PositionVelocityCovarianceType:
    class Meta:
        name = "positionVelocityCovarianceType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | PositionVelocityCovarianceUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class QuaternionDotComponentType:
    class Meta:
        name = "quaternionDotComponentType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | QuaternionDotUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class QuaternionEphemerisType:
    class Meta:
        name = "quaternionEphemerisType"

    epoch: str = field(
        metadata={
            "name": "EPOCH",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    quaternion: QuaternionType = field(
        metadata={
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class RelTimeType:
    class Meta:
        name = "relTimeType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | TimeUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class SensorNoiseType:
    class Meta:
        name = "sensorNoiseType"

    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    units: None | AngleUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class SigmaUtype:
    class Meta:
        name = "sigmaUType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | SigmaUunits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class SigmaVtype:
    class Meta:
        name = "sigmaVType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | SigmaVunits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class SolarFluxType:
    class Meta:
        name = "solarFluxType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | SolarFluxUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class TargetMomentumType:
    class Meta:
        name = "targetMomentumType"

    value: list[float] = field(
        default_factory=list,
        metadata={
            "length": 3,
            "tokens": True,
        },
    )
    units: None | AngMomentumUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class ThrustType:
    class Meta:
        name = "thrustType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | ThrustUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class TimeOffsetType:
    class Meta:
        name = "timeOffsetType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | TimeUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class TorqueType:
    class Meta:
        name = "torqueType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | TorqueUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class UserDefinedType:
    class Meta:
        name = "userDefinedType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
            "sequence": 1,
        },
    )
    user_defined: list[UserDefinedParameterType] = field(
        default_factory=list,
        metadata={
            "name": "USER_DEFINED",
            "type": "Element",
            "namespace": "",
            "sequence": 1,
        },
    )


@dataclass(kw_only=True)
class VelocityCovarianceType:
    class Meta:
        name = "velocityCovarianceType"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | VelocityCovarianceUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class VelocityTypeUo:
    class Meta:
        name = "velocityTypeUO"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: None | VelocityUnits = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


@dataclass(kw_only=True)
class VelocityTypeUr:
    class Meta:
        name = "velocityTypeUR"

    value: float = field(
        metadata={
            "required": True,
        }
    )
    units: VelocityUnits = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class WkgType:
    class Meta:
        name = "wkgType"

    value: float = field(
        metadata={
            "required": True,
            "min_inclusive": 0.0,
        }
    )
    units: WkgUnits = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class AngVelStateType:
    class Meta:
        name = "angVelStateType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    ref_frame_a: str = field(
        metadata={
            "name": "REF_FRAME_A",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    ref_frame_b: str = field(
        metadata={
            "name": "REF_FRAME_B",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angvel_frame: str = field(
        metadata={
            "name": "ANGVEL_FRAME",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angvel_x: AngVelComponentType = field(
        metadata={
            "name": "ANGVEL_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angvel_y: AngVelComponentType = field(
        metadata={
            "name": "ANGVEL_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angvel_z: AngVelComponentType = field(
        metadata={
            "name": "ANGVEL_Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class AngVelType:
    class Meta:
        name = "angVelType"

    angvel_x: AngVelComponentType = field(
        metadata={
            "name": "ANGVEL_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angvel_y: AngVelComponentType = field(
        metadata={
            "name": "ANGVEL_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angvel_z: AngVelComponentType = field(
        metadata={
            "name": "ANGVEL_Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class AtmosphericReentryParametersType:
    class Meta:
        name = "atmosphericReentryParametersType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    orbit_lifetime: DayIntervalTypeUr = field(
        metadata={
            "name": "ORBIT_LIFETIME",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    reentry_altitude: PositionTypeUr = field(
        metadata={
            "name": "REENTRY_ALTITUDE",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    orbit_lifetime_window_start: None | DayIntervalTypeUr = field(
        default=None,
        metadata={
            "name": "ORBIT_LIFETIME_WINDOW_START",
            "type": "Element",
            "namespace": "",
        },
    )
    orbit_lifetime_window_end: None | DayIntervalTypeUr = field(
        default=None,
        metadata={
            "name": "ORBIT_LIFETIME_WINDOW_END",
            "type": "Element",
            "namespace": "",
        },
    )
    nominal_reentry_epoch: None | str = field(
        default=None,
        metadata={
            "name": "NOMINAL_REENTRY_EPOCH",
            "type": "Element",
            "namespace": "",
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        },
    )
    reentry_window_start: None | str = field(
        default=None,
        metadata={
            "name": "REENTRY_WINDOW_START",
            "type": "Element",
            "namespace": "",
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        },
    )
    reentry_window_end: None | str = field(
        default=None,
        metadata={
            "name": "REENTRY_WINDOW_END",
            "type": "Element",
            "namespace": "",
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        },
    )
    orbit_lifetime_confidence_level: None | PercentageTypeUr = field(
        default=None,
        metadata={
            "name": "ORBIT_LIFETIME_CONFIDENCE_LEVEL",
            "type": "Element",
            "namespace": "",
        },
    )


@dataclass(kw_only=True)
class AttManeuverStateType:
    class Meta:
        name = "attManeuverStateType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    man_epoch_start: str = field(
        metadata={
            "name": "MAN_EPOCH_START",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    man_duration: DurationType = field(
        metadata={
            "name": "MAN_DURATION",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    man_ref_frame: str = field(
        metadata={
            "name": "MAN_REF_FRAME",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    man_tor_x: TorqueType = field(
        metadata={
            "name": "MAN_TOR_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    man_tor_y: TorqueType = field(
        metadata={
            "name": "MAN_TOR_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    man_tor_z: TorqueType = field(
        metadata={
            "name": "MAN_TOR_Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    man_delta_mass: None | DeltamassTypeZ = field(
        default=None,
        metadata={
            "name": "MAN_DELTA_MASS",
            "type": "Element",
            "namespace": "",
        },
    )


@dataclass(kw_only=True)
class EulerAngleAngVelType:
    class Meta:
        name = "eulerAngleAngVelType"

    epoch: str = field(
        metadata={
            "name": "EPOCH",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    angle_1: AngleType = field(
        metadata={
            "name": "ANGLE_1",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_2: AngleType = field(
        metadata={
            "name": "ANGLE_2",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_3: AngleType = field(
        metadata={
            "name": "ANGLE_3",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angvel_x: AngVelComponentType = field(
        metadata={
            "name": "ANGVEL_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angvel_y: AngVelComponentType = field(
        metadata={
            "name": "ANGVEL_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angvel_z: AngVelComponentType = field(
        metadata={
            "name": "ANGVEL_Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class EulerAngleDerivativeType:
    class Meta:
        name = "eulerAngleDerivativeType"

    epoch: str = field(
        metadata={
            "name": "EPOCH",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    angle_1: AngleType = field(
        metadata={
            "name": "ANGLE_1",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_2: AngleType = field(
        metadata={
            "name": "ANGLE_2",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_3: AngleType = field(
        metadata={
            "name": "ANGLE_3",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_1_dot: AngleRateType = field(
        metadata={
            "name": "ANGLE_1_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_2_dot: AngleRateType = field(
        metadata={
            "name": "ANGLE_2_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_3_dot: AngleRateType = field(
        metadata={
            "name": "ANGLE_3_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class EulerAngleStateType:
    class Meta:
        name = "eulerAngleStateType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    ref_frame_a: str = field(
        metadata={
            "name": "REF_FRAME_A",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    ref_frame_b: str = field(
        metadata={
            "name": "REF_FRAME_B",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    euler_rot_seq: RotseqType = field(
        metadata={
            "name": "EULER_ROT_SEQ",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_1: AngleType = field(
        metadata={
            "name": "ANGLE_1",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_2: AngleType = field(
        metadata={
            "name": "ANGLE_2",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_3: AngleType = field(
        metadata={
            "name": "ANGLE_3",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_1_dot: None | AngleRateType = field(
        default=None,
        metadata={
            "name": "ANGLE_1_DOT",
            "type": "Element",
            "namespace": "",
        },
    )
    angle_2_dot: None | AngleRateType = field(
        default=None,
        metadata={
            "name": "ANGLE_2_DOT",
            "type": "Element",
            "namespace": "",
        },
    )
    angle_3_dot: None | AngleRateType = field(
        default=None,
        metadata={
            "name": "ANGLE_3_DOT",
            "type": "Element",
            "namespace": "",
        },
    )


@dataclass(kw_only=True)
class EulerAngleType:
    class Meta:
        name = "eulerAngleType"

    epoch: str = field(
        metadata={
            "name": "EPOCH",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    angle_1: AngleType = field(
        metadata={
            "name": "ANGLE_1",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_2: AngleType = field(
        metadata={
            "name": "ANGLE_2",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    angle_3: AngleType = field(
        metadata={
            "name": "ANGLE_3",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class GroundImpactParametersType:
    class Meta:
        name = "groundImpactParametersType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    probability_of_impact: None | float = field(
        default=None,
        metadata={
            "name": "PROBABILITY_OF_IMPACT",
            "type": "Element",
            "namespace": "",
            "min_inclusive": 0.0,
            "max_inclusive": 1.0,
        },
    )
    probability_of_burn_up: None | float = field(
        default=None,
        metadata={
            "name": "PROBABILITY_OF_BURN_UP",
            "type": "Element",
            "namespace": "",
            "min_inclusive": 0.0,
            "max_inclusive": 1.0,
        },
    )
    probability_of_break_up: None | float = field(
        default=None,
        metadata={
            "name": "PROBABILITY_OF_BREAK_UP",
            "type": "Element",
            "namespace": "",
            "min_inclusive": 0.0,
            "max_inclusive": 1.0,
        },
    )
    probability_of_land_impact: None | float = field(
        default=None,
        metadata={
            "name": "PROBABILITY_OF_LAND_IMPACT",
            "type": "Element",
            "namespace": "",
            "min_inclusive": 0.0,
            "max_inclusive": 1.0,
        },
    )
    probability_of_casualty: None | float = field(
        default=None,
        metadata={
            "name": "PROBABILITY_OF_CASUALTY",
            "type": "Element",
            "namespace": "",
            "min_inclusive": 0.0,
            "max_inclusive": 1.0,
        },
    )
    nominal_impact_epoch: None | str = field(
        default=None,
        metadata={
            "name": "NOMINAL_IMPACT_EPOCH",
            "type": "Element",
            "namespace": "",
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        },
    )
    impact_window_start: None | str = field(
        default=None,
        metadata={
            "name": "IMPACT_WINDOW_START",
            "type": "Element",
            "namespace": "",
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        },
    )
    impact_window_end: None | str = field(
        default=None,
        metadata={
            "name": "IMPACT_WINDOW_END",
            "type": "Element",
            "namespace": "",
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        },
    )
    impact_ref_frame: None | str = field(
        default=None,
        metadata={
            "name": "IMPACT_REF_FRAME",
            "type": "Element",
            "namespace": "",
        },
    )
    nominal_impact_lon: None | LonType = field(
        default=None,
        metadata={
            "name": "NOMINAL_IMPACT_LON",
            "type": "Element",
            "namespace": "",
        },
    )
    nominal_impact_lat: None | LatType = field(
        default=None,
        metadata={
            "name": "NOMINAL_IMPACT_LAT",
            "type": "Element",
            "namespace": "",
        },
    )
    nominal_impact_alt: None | AltType = field(
        default=None,
        metadata={
            "name": "NOMINAL_IMPACT_ALT",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_1_confidence: None | PercentageTypeUr = field(
        default=None,
        metadata={
            "name": "IMPACT_1_CONFIDENCE",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_1_start_lon: None | LonType = field(
        default=None,
        metadata={
            "name": "IMPACT_1_START_LON",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_1_start_lat: None | LatType = field(
        default=None,
        metadata={
            "name": "IMPACT_1_START_LAT",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_1_stop_lon: None | LonType = field(
        default=None,
        metadata={
            "name": "IMPACT_1_STOP_LON",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_1_stop_lat: None | LatType = field(
        default=None,
        metadata={
            "name": "IMPACT_1_STOP_LAT",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_1_cross_track: None | DistanceType = field(
        default=None,
        metadata={
            "name": "IMPACT_1_CROSS_TRACK",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_2_confidence: None | PercentageTypeUr = field(
        default=None,
        metadata={
            "name": "IMPACT_2_CONFIDENCE",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_2_start_lon: None | LonType = field(
        default=None,
        metadata={
            "name": "IMPACT_2_START_LON",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_2_start_lat: None | LatType = field(
        default=None,
        metadata={
            "name": "IMPACT_2_START_LAT",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_2_stop_lon: None | LonType = field(
        default=None,
        metadata={
            "name": "IMPACT_2_STOP_LON",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_2_stop_lat: None | LatType = field(
        default=None,
        metadata={
            "name": "IMPACT_2_STOP_LAT",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_2_cross_track: None | DistanceType = field(
        default=None,
        metadata={
            "name": "IMPACT_2_CROSS_TRACK",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_3_confidence: None | PercentageTypeUr = field(
        default=None,
        metadata={
            "name": "IMPACT_3_CONFIDENCE",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_3_start_lon: None | LonType = field(
        default=None,
        metadata={
            "name": "IMPACT_3_START_LON",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_3_start_lat: None | LatType = field(
        default=None,
        metadata={
            "name": "IMPACT_3_START_LAT",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_3_stop_lon: None | LonType = field(
        default=None,
        metadata={
            "name": "IMPACT_3_STOP_LON",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_3_stop_lat: None | LatType = field(
        default=None,
        metadata={
            "name": "IMPACT_3_STOP_LAT",
            "type": "Element",
            "namespace": "",
        },
    )
    impact_3_cross_track: None | DistanceType = field(
        default=None,
        metadata={
            "name": "IMPACT_3_CROSS_TRACK",
            "type": "Element",
            "namespace": "",
        },
    )


@dataclass(kw_only=True)
class InertiaStateType:
    class Meta:
        name = "inertiaStateType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    inertia_ref_frame: str = field(
        metadata={
            "name": "INERTIA_REF_FRAME",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    ixx: MomentType = field(
        metadata={
            "name": "IXX",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    iyy: MomentType = field(
        metadata={
            "name": "IYY",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    izz: MomentType = field(
        metadata={
            "name": "IZZ",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    ixy: MomentType = field(
        metadata={
            "name": "IXY",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    ixz: MomentType = field(
        metadata={
            "name": "IXZ",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    iyz: MomentType = field(
        metadata={
            "name": "IYZ",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class OdParametersType:
    class Meta:
        name = "odParametersType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    time_lastob_start: None | str = field(
        default=None,
        metadata={
            "name": "TIME_LASTOB_START",
            "type": "Element",
            "namespace": "",
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        },
    )
    time_lastob_end: None | str = field(
        default=None,
        metadata={
            "name": "TIME_LASTOB_END",
            "type": "Element",
            "namespace": "",
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        },
    )
    recommended_od_span: None | DayIntervalTypeUo = field(
        default=None,
        metadata={
            "name": "RECOMMENDED_OD_SPAN",
            "type": "Element",
            "namespace": "",
        },
    )
    actual_od_span: None | DayIntervalTypeUo = field(
        default=None,
        metadata={
            "name": "ACTUAL_OD_SPAN",
            "type": "Element",
            "namespace": "",
        },
    )
    obs_available: None | int = field(
        default=None,
        metadata={
            "name": "OBS_AVAILABLE",
            "type": "Element",
            "namespace": "",
        },
    )
    obs_used: None | int = field(
        default=None,
        metadata={
            "name": "OBS_USED",
            "type": "Element",
            "namespace": "",
        },
    )
    tracks_available: None | int = field(
        default=None,
        metadata={
            "name": "TRACKS_AVAILABLE",
            "type": "Element",
            "namespace": "",
        },
    )
    tracks_used: None | int = field(
        default=None,
        metadata={
            "name": "TRACKS_USED",
            "type": "Element",
            "namespace": "",
        },
    )
    residuals_accepted: None | PercentageTypeUo = field(
        default=None,
        metadata={
            "name": "RESIDUALS_ACCEPTED",
            "type": "Element",
            "namespace": "",
        },
    )
    weighted_rms: None | float = field(
        default=None,
        metadata={
            "name": "WEIGHTED_RMS",
            "type": "Element",
            "namespace": "",
            "min_inclusive": 0.0,
        },
    )


@dataclass(kw_only=True)
class OemCovarianceMatrixType(OemCovarianceMatrixAbstractType):
    class Meta:
        name = "oemCovarianceMatrixType"

    cx_x: PositionCovarianceType = field(
        metadata={
            "name": "CX_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_x: PositionCovarianceType = field(
        metadata={
            "name": "CY_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_y: PositionCovarianceType = field(
        metadata={
            "name": "CY_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_x: PositionCovarianceType = field(
        metadata={
            "name": "CZ_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_y: PositionCovarianceType = field(
        metadata={
            "name": "CZ_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_z: PositionCovarianceType = field(
        metadata={
            "name": "CZ_Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cx_dot_x: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CX_DOT_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cx_dot_y: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CX_DOT_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cx_dot_z: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CX_DOT_Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cx_dot_x_dot: VelocityCovarianceType = field(
        metadata={
            "name": "CX_DOT_X_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_dot_x: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CY_DOT_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_dot_y: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CY_DOT_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_dot_z: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CY_DOT_Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_dot_x_dot: VelocityCovarianceType = field(
        metadata={
            "name": "CY_DOT_X_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_dot_y_dot: VelocityCovarianceType = field(
        metadata={
            "name": "CY_DOT_Y_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_dot_x: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CZ_DOT_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_dot_y: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CZ_DOT_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_dot_z: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CZ_DOT_Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_dot_x_dot: VelocityCovarianceType = field(
        metadata={
            "name": "CZ_DOT_X_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_dot_y_dot: VelocityCovarianceType = field(
        metadata={
            "name": "CZ_DOT_Y_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_dot_z_dot: VelocityCovarianceType = field(
        metadata={
            "name": "CZ_DOT_Z_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class OpmCovarianceMatrixType(OpmCovarianceMatrixAbstractType):
    class Meta:
        name = "opmCovarianceMatrixType"

    cx_x: PositionCovarianceType = field(
        metadata={
            "name": "CX_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_x: PositionCovarianceType = field(
        metadata={
            "name": "CY_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_y: PositionCovarianceType = field(
        metadata={
            "name": "CY_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_x: PositionCovarianceType = field(
        metadata={
            "name": "CZ_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_y: PositionCovarianceType = field(
        metadata={
            "name": "CZ_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_z: PositionCovarianceType = field(
        metadata={
            "name": "CZ_Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cx_dot_x: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CX_DOT_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cx_dot_y: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CX_DOT_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cx_dot_z: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CX_DOT_Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cx_dot_x_dot: VelocityCovarianceType = field(
        metadata={
            "name": "CX_DOT_X_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_dot_x: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CY_DOT_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_dot_y: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CY_DOT_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_dot_z: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CY_DOT_Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_dot_x_dot: VelocityCovarianceType = field(
        metadata={
            "name": "CY_DOT_X_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cy_dot_y_dot: VelocityCovarianceType = field(
        metadata={
            "name": "CY_DOT_Y_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_dot_x: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CZ_DOT_X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_dot_y: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CZ_DOT_Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_dot_z: PositionVelocityCovarianceType = field(
        metadata={
            "name": "CZ_DOT_Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_dot_x_dot: VelocityCovarianceType = field(
        metadata={
            "name": "CZ_DOT_X_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_dot_y_dot: VelocityCovarianceType = field(
        metadata={
            "name": "CZ_DOT_Y_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    cz_dot_z_dot: VelocityCovarianceType = field(
        metadata={
            "name": "CZ_DOT_Z_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class QuaternionDotType:
    class Meta:
        name = "quaternionDotType"

    q1_dot: QuaternionDotComponentType = field(
        metadata={
            "name": "Q1_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    q2_dot: QuaternionDotComponentType = field(
        metadata={
            "name": "Q2_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    q3_dot: QuaternionDotComponentType = field(
        metadata={
            "name": "Q3_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    qc_dot: QuaternionDotComponentType = field(
        metadata={
            "name": "QC_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class RdmSpacecraftParametersType:
    class Meta:
        name = "rdmSpacecraftParametersType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    wet_mass: None | MassType = field(
        default=None,
        metadata={
            "name": "WET_MASS",
            "type": "Element",
            "namespace": "",
        },
    )
    dry_mass: None | MassType = field(
        default=None,
        metadata={
            "name": "DRY_MASS",
            "type": "Element",
            "namespace": "",
        },
    )
    hazardous_substances: None | str = field(
        default=None,
        metadata={
            "name": "HAZARDOUS_SUBSTANCES",
            "type": "Element",
            "namespace": "",
        },
    )
    solar_rad_area: None | AreaType = field(
        default=None,
        metadata={
            "name": "SOLAR_RAD_AREA",
            "type": "Element",
            "namespace": "",
        },
    )
    solar_rad_coeff: None | float = field(
        default=None,
        metadata={
            "name": "SOLAR_RAD_COEFF",
            "type": "Element",
            "namespace": "",
            "min_inclusive": 0.0,
        },
    )
    drag_area: None | AreaType = field(
        default=None,
        metadata={
            "name": "DRAG_AREA",
            "type": "Element",
            "namespace": "",
        },
    )
    drag_coeff: None | float = field(
        default=None,
        metadata={
            "name": "DRAG_COEFF",
            "type": "Element",
            "namespace": "",
            "min_inclusive": 0.0,
        },
    )
    rcs: None | AreaType = field(
        default=None,
        metadata={
            "name": "RCS",
            "type": "Element",
            "namespace": "",
        },
    )
    ballistic_coeff: None | BallisticCoeffType = field(
        default=None,
        metadata={
            "name": "BALLISTIC_COEFF",
            "type": "Element",
            "namespace": "",
        },
    )
    thrust_acceleration: None | Ms2Type = field(
        default=None,
        metadata={
            "name": "THRUST_ACCELERATION",
            "type": "Element",
            "namespace": "",
        },
    )


@dataclass(kw_only=True)
class SpacecraftParametersType:
    class Meta:
        name = "spacecraftParametersType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    mass: None | MassType = field(
        default=None,
        metadata={
            "name": "MASS",
            "type": "Element",
            "namespace": "",
        },
    )
    solar_rad_area: None | AreaType = field(
        default=None,
        metadata={
            "name": "SOLAR_RAD_AREA",
            "type": "Element",
            "namespace": "",
        },
    )
    solar_rad_coeff: None | float = field(
        default=None,
        metadata={
            "name": "SOLAR_RAD_COEFF",
            "type": "Element",
            "namespace": "",
            "min_inclusive": 0.0,
        },
    )
    drag_area: None | AreaType = field(
        default=None,
        metadata={
            "name": "DRAG_AREA",
            "type": "Element",
            "namespace": "",
        },
    )
    drag_coeff: None | float = field(
        default=None,
        metadata={
            "name": "DRAG_COEFF",
            "type": "Element",
            "namespace": "",
            "min_inclusive": 0.0,
        },
    )


@dataclass(kw_only=True)
class SpinNutationMomType:
    class Meta:
        name = "spinNutationMomType"

    epoch: str = field(
        metadata={
            "name": "EPOCH",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    spin_alpha: AngleType = field(
        metadata={
            "name": "SPIN_ALPHA",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_delta: AngleType = field(
        metadata={
            "name": "SPIN_DELTA",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_angle: AngleType = field(
        metadata={
            "name": "SPIN_ANGLE",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_angle_vel: AngleRateType = field(
        metadata={
            "name": "SPIN_ANGLE_VEL",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    momentum_alpha: AngleType = field(
        metadata={
            "name": "MOMENTUM_ALPHA",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    momentum_delta: AngleType = field(
        metadata={
            "name": "MOMENTUM_DELTA",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    nutation_vel: AngleRateType = field(
        metadata={
            "name": "NUTATION_VEL",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class SpinNutationType:
    class Meta:
        name = "spinNutationType"

    epoch: str = field(
        metadata={
            "name": "EPOCH",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    spin_alpha: AngleType = field(
        metadata={
            "name": "SPIN_ALPHA",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_delta: AngleType = field(
        metadata={
            "name": "SPIN_DELTA",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_angle: AngleType = field(
        metadata={
            "name": "SPIN_ANGLE",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_angle_vel: AngleRateType = field(
        metadata={
            "name": "SPIN_ANGLE_VEL",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    nutation: AngleType = field(
        metadata={
            "name": "NUTATION",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    nutation_per: DurationType = field(
        metadata={
            "name": "NUTATION_PER",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    nutation_phase: AngleType = field(
        metadata={
            "name": "NUTATION_PHASE",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class SpinStateType:
    class Meta:
        name = "spinStateType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    ref_frame_a: str = field(
        metadata={
            "name": "REF_FRAME_A",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    ref_frame_b: str = field(
        metadata={
            "name": "REF_FRAME_B",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_alpha: AngleType = field(
        metadata={
            "name": "SPIN_ALPHA",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_delta: AngleType = field(
        metadata={
            "name": "SPIN_DELTA",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_angle: AngleType = field(
        metadata={
            "name": "SPIN_ANGLE",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_angle_vel: AngleRateType = field(
        metadata={
            "name": "SPIN_ANGLE_VEL",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    nutation: None | AngleType = field(
        default=None,
        metadata={
            "name": "NUTATION",
            "type": "Element",
            "namespace": "",
        },
    )
    nutation_per: None | DurationType = field(
        default=None,
        metadata={
            "name": "NUTATION_PER",
            "type": "Element",
            "namespace": "",
        },
    )
    nutation_phase: None | AngleType = field(
        default=None,
        metadata={
            "name": "NUTATION_PHASE",
            "type": "Element",
            "namespace": "",
        },
    )
    momentum_alpha: None | AngleType = field(
        default=None,
        metadata={
            "name": "MOMENTUM_ALPHA",
            "type": "Element",
            "namespace": "",
        },
    )
    momentum_delta: None | AngleType = field(
        default=None,
        metadata={
            "name": "MOMENTUM_DELTA",
            "type": "Element",
            "namespace": "",
        },
    )
    nutation_vel: None | AngleRateType = field(
        default=None,
        metadata={
            "name": "NUTATION_VEL",
            "type": "Element",
            "namespace": "",
        },
    )


@dataclass(kw_only=True)
class SpinType:
    class Meta:
        name = "spinType"

    epoch: str = field(
        metadata={
            "name": "EPOCH",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    spin_alpha: AngleType = field(
        metadata={
            "name": "SPIN_ALPHA",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_delta: AngleType = field(
        metadata={
            "name": "SPIN_DELTA",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_angle: AngleType = field(
        metadata={
            "name": "SPIN_ANGLE",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    spin_angle_vel: AngleRateType = field(
        metadata={
            "name": "SPIN_ANGLE_VEL",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class StateVectorAccType:
    class Meta:
        name = "stateVectorAccType"

    epoch: str = field(
        metadata={
            "name": "EPOCH",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    x: PositionTypeUo = field(
        metadata={
            "name": "X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    y: PositionTypeUo = field(
        metadata={
            "name": "Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    z: PositionTypeUo = field(
        metadata={
            "name": "Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    x_dot: VelocityTypeUo = field(
        metadata={
            "name": "X_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    y_dot: VelocityTypeUo = field(
        metadata={
            "name": "Y_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    z_dot: VelocityTypeUo = field(
        metadata={
            "name": "Z_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    x_ddot: None | AccType = field(
        default=None,
        metadata={
            "name": "X_DDOT",
            "type": "Element",
            "namespace": "",
        },
    )
    y_ddot: None | AccType = field(
        default=None,
        metadata={
            "name": "Y_DDOT",
            "type": "Element",
            "namespace": "",
        },
    )
    z_ddot: None | AccType = field(
        default=None,
        metadata={
            "name": "Z_DDOT",
            "type": "Element",
            "namespace": "",
        },
    )


@dataclass(kw_only=True)
class StateVectorType:
    class Meta:
        name = "stateVectorType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    epoch: str = field(
        metadata={
            "name": "EPOCH",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    x: PositionTypeUo = field(
        metadata={
            "name": "X",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    y: PositionTypeUo = field(
        metadata={
            "name": "Y",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    z: PositionTypeUo = field(
        metadata={
            "name": "Z",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    x_dot: VelocityTypeUo = field(
        metadata={
            "name": "X_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    y_dot: VelocityTypeUo = field(
        metadata={
            "name": "Y_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    z_dot: VelocityTypeUo = field(
        metadata={
            "name": "Z_DOT",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class QuaternionAngVelType:
    class Meta:
        name = "quaternionAngVelType"

    epoch: str = field(
        metadata={
            "name": "EPOCH",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    quaternion: QuaternionType = field(
        metadata={
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    ang_vel: AngVelType = field(
        metadata={
            "name": "angVel",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class QuaternionDerivativeType:
    class Meta:
        name = "quaternionDerivativeType"

    epoch: str = field(
        metadata={
            "name": "EPOCH",
            "type": "Element",
            "namespace": "",
            "required": True,
            "pattern": r"\-?\d{4}\d*-((\d{2}\-\d{2})|\d{3})T\d{2}:\d{2}:\d{2}(\.\d*)?(Z|[+|\-]\d{2}:\d{2})?|[+|\-]?\d*(\.\d*)?",
        }
    )
    quaternion: QuaternionType = field(
        metadata={
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    quaternion_dot: QuaternionDotType = field(
        metadata={
            "name": "quaternionDot",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )


@dataclass(kw_only=True)
class QuaternionStateType:
    class Meta:
        name = "quaternionStateType"

    comment: list[str] = field(
        default_factory=list,
        metadata={
            "name": "COMMENT",
            "type": "Element",
            "namespace": "",
        },
    )
    ref_frame_a: str = field(
        metadata={
            "name": "REF_FRAME_A",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    ref_frame_b: str = field(
        metadata={
            "name": "REF_FRAME_B",
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    quaternion: QuaternionType = field(
        metadata={
            "type": "Element",
            "namespace": "",
            "required": True,
        }
    )
    quaternion_dot: None | QuaternionDotType = field(
        default=None,
        metadata={
            "name": "quaternionDot",
            "type": "Element",
            "namespace": "",
        },
    )


@dataclass(kw_only=True)
class AttitudeStateType:
    class Meta:
        name = "attitudeStateType"

    quaternion_ephemeris: None | QuaternionEphemerisType = field(
        default=None,
        metadata={
            "name": "quaternionEphemeris",
            "type": "Element",
            "namespace": "",
        },
    )
    quaternion_derivative: None | QuaternionDerivativeType = field(
        default=None,
        metadata={
            "name": "quaternionDerivative",
            "type": "Element",
            "namespace": "",
        },
    )
    quaternion_ang_vel: None | QuaternionAngVelType = field(
        default=None,
        metadata={
            "name": "quaternionAngVel",
            "type": "Element",
            "namespace": "",
        },
    )
    euler_angle: None | EulerAngleType = field(
        default=None,
        metadata={
            "name": "eulerAngle",
            "type": "Element",
            "namespace": "",
        },
    )
    euler_angle_derivative: None | EulerAngleDerivativeType = field(
        default=None,
        metadata={
            "name": "eulerAngleDerivative",
            "type": "Element",
            "namespace": "",
        },
    )
    euler_angle_ang_vel: None | EulerAngleAngVelType = field(
        default=None,
        metadata={
            "name": "eulerAngleAngVel",
            "type": "Element",
            "namespace": "",
        },
    )
    spin: None | SpinType = field(
        default=None,
        metadata={
            "type": "Element",
            "namespace": "",
        },
    )
    spin_nutation: None | SpinNutationType = field(
        default=None,
        metadata={
            "name": "spinNutation",
            "type": "Element",
            "namespace": "",
        },
    )
    spin_nutation_mom: None | SpinNutationMomType = field(
        default=None,
        metadata={
            "name": "spinNutationMom",
            "type": "Element",
            "namespace": "",
        },
    )
