/****************************************************************************
** Meta object code from reading C++ file 'Satellites.hpp'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.0)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../../../../../stellarium/plugins/Satellites/src/Satellites.hpp"
#include <QtCore/qmetatype.h>
#include <QtCore/qplugin.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'Satellites.hpp' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN10SatellitesE_t {};
} // unnamed namespace

template <> constexpr inline auto Satellites::qt_create_metaobjectdata<qt_meta_tag_ZN10SatellitesE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Satellites",
        "flagHintsVisibleChanged",
        "",
        "b",
        "flagLabelsVisibleChanged",
        "labelFontSizeChanged",
        "s",
        "flagOrbitLinesChanged",
        "flagIconicModeChanged",
        "flagHideInvisibleChanged",
        "flagColoredInvisibleChanged",
        "updatesEnabledChanged",
        "updateFrequencyHoursChanged",
        "i",
        "autoAddEnabledChanged",
        "autoRemoveEnabledChanged",
        "autoDisplayEnabledChanged",
        "orbitLineSegmentsChanged",
        "orbitLineFadeSegmentsChanged",
        "orbitLineThicknessChanged",
        "orbitLineSegmentDurationChanged",
        "tleEpochAgeDaysChanged",
        "invisibleSatelliteColorChanged",
        "Vec3f",
        "transitSatelliteColorChanged",
        "flagUmbraVisibleChanged",
        "flagUmbraAtFixedAltitudeChanged",
        "umbraColorChanged",
        "umbraAltitudeChanged",
        "d",
        "flagPenumbraVisibleChanged",
        "penumbraColorChanged",
        "flagCFKnownStdMagnitudeChanged",
        "flagCFApogeeChanged",
        "minCFApogeeChanged",
        "v",
        "maxCFApogeeChanged",
        "flagCFPerigeeChanged",
        "minCFPerigeeChanged",
        "maxCFPerigeeChanged",
        "flagCFEccentricityChanged",
        "minCFEccentricityChanged",
        "maxCFEccentricityChanged",
        "flagCFPeriodChanged",
        "minCFPeriodChanged",
        "maxCFPeriodChanged",
        "flagCFInclinationChanged",
        "minCFInclinationChanged",
        "maxCFInclinationChanged",
        "flagCFRCSChanged",
        "minCFRCSChanged",
        "maxCFRCSChanged",
        "flagVFAltitudeChanged",
        "minVFAltitudeChanged",
        "maxVFAltitudeChanged",
        "flagVFMagnitudeChanged",
        "minVFMagnitudeChanged",
        "maxVFMagnitudeChanged",
        "settingsChanged",
        "customFilterChanged",
        "updateStateChanged",
        "Satellites::UpdateState",
        "state",
        "tleUpdateComplete",
        "updated",
        "total",
        "added",
        "missing",
        "satGroupVisibleChanged",
        "satSelectionChanged",
        "satID",
        "getUpdatesEnabled",
        "setUpdatesEnabled",
        "enabled",
        "isAutoAddEnabled",
        "setAutoAddEnabled",
        "isAutoRemoveEnabled",
        "setAutoRemoveEnabled",
        "isAutoDisplayEnabled",
        "setAutoDisplayEnabled",
        "setFlagHintsVisible",
        "getFlagHintsVisible",
        "setFlagLabelsVisible",
        "getFlagLabelsVisible",
        "setFlagIconicMode",
        "getFlagIconicMode",
        "getFlagHideInvisible",
        "setFlagHideInvisible",
        "getFlagColoredInvisible",
        "setFlagColoredInvisible",
        "getInvisibleSatelliteColor",
        "setInvisibleSatelliteColor",
        "c",
        "getTransitSatelliteColor",
        "setTransitSatelliteColor",
        "getLabelFontSize",
        "setLabelFontSize",
        "size",
        "setUpdateFrequencyHours",
        "hours",
        "updateFromOnlineSources",
        "setFlagOrbitLines",
        "getFlagOrbitLines",
        "getOrbitLineSegments",
        "setOrbitLineSegments",
        "getOrbitLineFadeSegments",
        "setOrbitLineFadeSegments",
        "getOrbitLineThickness",
        "setOrbitLineThickness",
        "getOrbitLineSegmentDuration",
        "setOrbitLineSegmentDuration",
        "getTleEpochAgeDays",
        "setTleEpochAgeDays",
        "age",
        "recalculateOrbitLines",
        "setFlagUmbraVisible",
        "getFlagUmbraVisible",
        "setFlagUmbraAtFixedAltitude",
        "getFlagUmbraAtFixedAltitude",
        "getUmbraColor",
        "setUmbraColor",
        "getUmbraAltitude",
        "setUmbraAltitude",
        "setFlagPenumbraVisible",
        "getFlagPenumbraVisible",
        "getPenumbraColor",
        "setPenumbraColor",
        "displayMessage",
        "message",
        "hexColor",
        "saveCatalog",
        "path",
        "setFlagCFKnownStdMagnitude",
        "getFlagCFKnownStdMagnitude",
        "setFlagCFApogee",
        "getFlagCFApogee",
        "setMaxCFApogee",
        "getMaxCFApogee",
        "setMinCFApogee",
        "getMinCFApogee",
        "setFlagCFPerigee",
        "getFlagCFPerigee",
        "setMaxCFPerigee",
        "getMaxCFPerigee",
        "setMinCFPerigee",
        "getMinCFPerigee",
        "setFlagVFAltitude",
        "getFlagVFAltitude",
        "setMaxVFAltitude",
        "getMaxVFAltitude",
        "setMinVFAltitude",
        "getMinVFAltitude",
        "setFlagVFMagnitude",
        "getFlagVFMagnitude",
        "setMaxVFMagnitude",
        "getMaxVFMagnitude",
        "setMinVFMagnitude",
        "getMinVFMagnitude",
        "setFlagCFEccentricity",
        "getFlagCFEccentricity",
        "setMaxCFEccentricity",
        "getMaxCFEccentricity",
        "setMinCFEccentricity",
        "getMinCFEccentricity",
        "setFlagCFPeriod",
        "getFlagCFPeriod",
        "setMaxCFPeriod",
        "getMaxCFPeriod",
        "setMinCFPeriod",
        "getMinCFPeriod",
        "setFlagCFInclination",
        "getFlagCFInclination",
        "setMaxCFInclination",
        "getMaxCFInclination",
        "setMinCFInclination",
        "getMinCFInclination",
        "setFlagCFRCS",
        "getFlagCFRCS",
        "setMaxCFRCS",
        "getMaxCFRCS",
        "setMinCFRCS",
        "getMinCFRCS",
        "updateSatellitesVisibility",
        "saveSettings",
        "translateData",
        "checkForUpdate",
        "saveDownloadedUpdate",
        "QNetworkReply*",
        "reply",
        "updateObserverLocation",
        "StelLocation",
        "loc",
        "changeSelectedSatellite",
        "id",
        "flagHintsVisible",
        "flagLabelsVisible",
        "labelFontSize",
        "autoAddEnabled",
        "autoRemoveEnabled",
        "autoDisplayEnabled",
        "flagIconicMode",
        "flagHideInvisible",
        "flagColoredInvisible",
        "flagOrbitLines",
        "updatesEnabled",
        "updateFrequencyHours",
        "orbitLineSegments",
        "orbitLineFadeSegments",
        "orbitLineSegmentDuration",
        "orbitLineThickness",
        "tleEpochAgeDays",
        "invisibleSatelliteColor",
        "transitSatelliteColor",
        "flagUmbraVisible",
        "flagUmbraAtFixedAltitude",
        "umbraAltitude",
        "umbraColor",
        "flagPenumbraVisible",
        "penumbraColor",
        "flagCFKnownStdMagnitude",
        "flagCFApogee",
        "minCFApogee",
        "maxCFApogee",
        "flagCFPerigee",
        "minCFPerigee",
        "maxCFPerigee",
        "flagCFEccentricity",
        "minCFEccentricity",
        "maxCFEccentricity",
        "flagCFPeriod",
        "minCFPeriod",
        "maxCFPeriod",
        "flagCFInclination",
        "minCFInclination",
        "maxCFInclination",
        "flagCFRCS",
        "minCFRCS",
        "maxCFRCS",
        "flagVFAltitude",
        "minVFAltitude",
        "maxVFAltitude",
        "flagVFMagnitude",
        "minVFMagnitude",
        "maxVFMagnitude"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'flagHintsVisibleChanged'
        QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagLabelsVisibleChanged'
        QtMocHelpers::SignalData<void(bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'labelFontSizeChanged'
        QtMocHelpers::SignalData<void(int)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 6 },
        }}),
        // Signal 'flagOrbitLinesChanged'
        QtMocHelpers::SignalData<void(bool)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagIconicModeChanged'
        QtMocHelpers::SignalData<void(bool)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagHideInvisibleChanged'
        QtMocHelpers::SignalData<void(bool)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagColoredInvisibleChanged'
        QtMocHelpers::SignalData<void(bool)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'updatesEnabledChanged'
        QtMocHelpers::SignalData<void(bool)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'updateFrequencyHoursChanged'
        QtMocHelpers::SignalData<void(int)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Signal 'autoAddEnabledChanged'
        QtMocHelpers::SignalData<void(bool)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'autoRemoveEnabledChanged'
        QtMocHelpers::SignalData<void(bool)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'autoDisplayEnabledChanged'
        QtMocHelpers::SignalData<void(bool)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'orbitLineSegmentsChanged'
        QtMocHelpers::SignalData<void(int)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Signal 'orbitLineFadeSegmentsChanged'
        QtMocHelpers::SignalData<void(int)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Signal 'orbitLineThicknessChanged'
        QtMocHelpers::SignalData<void(int)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Signal 'orbitLineSegmentDurationChanged'
        QtMocHelpers::SignalData<void(int)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Signal 'tleEpochAgeDaysChanged'
        QtMocHelpers::SignalData<void(int)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Signal 'invisibleSatelliteColorChanged'
        QtMocHelpers::SignalData<void(Vec3f)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 2 },
        }}),
        // Signal 'transitSatelliteColorChanged'
        QtMocHelpers::SignalData<void(Vec3f)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 2 },
        }}),
        // Signal 'flagUmbraVisibleChanged'
        QtMocHelpers::SignalData<void(bool)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagUmbraAtFixedAltitudeChanged'
        QtMocHelpers::SignalData<void(bool)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'umbraColorChanged'
        QtMocHelpers::SignalData<void(Vec3f)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 2 },
        }}),
        // Signal 'umbraAltitudeChanged'
        QtMocHelpers::SignalData<void(double)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 29 },
        }}),
        // Signal 'flagPenumbraVisibleChanged'
        QtMocHelpers::SignalData<void(bool)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'penumbraColorChanged'
        QtMocHelpers::SignalData<void(Vec3f)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 2 },
        }}),
        // Signal 'flagCFKnownStdMagnitudeChanged'
        QtMocHelpers::SignalData<void(bool)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagCFApogeeChanged'
        QtMocHelpers::SignalData<void(bool)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'minCFApogeeChanged'
        QtMocHelpers::SignalData<void(double)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'maxCFApogeeChanged'
        QtMocHelpers::SignalData<void(double)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'flagCFPerigeeChanged'
        QtMocHelpers::SignalData<void(bool)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'minCFPerigeeChanged'
        QtMocHelpers::SignalData<void(double)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'maxCFPerigeeChanged'
        QtMocHelpers::SignalData<void(double)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'flagCFEccentricityChanged'
        QtMocHelpers::SignalData<void(bool)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'minCFEccentricityChanged'
        QtMocHelpers::SignalData<void(double)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'maxCFEccentricityChanged'
        QtMocHelpers::SignalData<void(double)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'flagCFPeriodChanged'
        QtMocHelpers::SignalData<void(bool)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'minCFPeriodChanged'
        QtMocHelpers::SignalData<void(double)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'maxCFPeriodChanged'
        QtMocHelpers::SignalData<void(double)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'flagCFInclinationChanged'
        QtMocHelpers::SignalData<void(bool)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'minCFInclinationChanged'
        QtMocHelpers::SignalData<void(double)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'maxCFInclinationChanged'
        QtMocHelpers::SignalData<void(double)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'flagCFRCSChanged'
        QtMocHelpers::SignalData<void(bool)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'minCFRCSChanged'
        QtMocHelpers::SignalData<void(double)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'maxCFRCSChanged'
        QtMocHelpers::SignalData<void(double)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'flagVFAltitudeChanged'
        QtMocHelpers::SignalData<void(bool)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'minVFAltitudeChanged'
        QtMocHelpers::SignalData<void(double)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'maxVFAltitudeChanged'
        QtMocHelpers::SignalData<void(double)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'flagVFMagnitudeChanged'
        QtMocHelpers::SignalData<void(bool)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'minVFMagnitudeChanged'
        QtMocHelpers::SignalData<void(double)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'maxVFMagnitudeChanged'
        QtMocHelpers::SignalData<void(double)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Signal 'settingsChanged'
        QtMocHelpers::SignalData<void()>(58, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'customFilterChanged'
        QtMocHelpers::SignalData<void()>(59, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'updateStateChanged'
        QtMocHelpers::SignalData<void(Satellites::UpdateState)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 61, 62 },
        }}),
        // Signal 'tleUpdateComplete'
        QtMocHelpers::SignalData<void(int, int, int, int)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 64 }, { QMetaType::Int, 65 }, { QMetaType::Int, 66 }, { QMetaType::Int, 67 },
        }}),
        // Signal 'satGroupVisibleChanged'
        QtMocHelpers::SignalData<void()>(68, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'satSelectionChanged'
        QtMocHelpers::SignalData<void(const QString &)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 70 },
        }}),
        // Slot 'getUpdatesEnabled'
        QtMocHelpers::SlotData<bool()>(71, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setUpdatesEnabled'
        QtMocHelpers::SlotData<void(bool)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 73 },
        }}),
        // Slot 'isAutoAddEnabled'
        QtMocHelpers::SlotData<bool()>(74, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setAutoAddEnabled'
        QtMocHelpers::SlotData<void(bool)>(75, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 73 },
        }}),
        // Slot 'isAutoRemoveEnabled'
        QtMocHelpers::SlotData<bool()>(76, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setAutoRemoveEnabled'
        QtMocHelpers::SlotData<void(bool)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 73 },
        }}),
        // Slot 'isAutoDisplayEnabled'
        QtMocHelpers::SlotData<bool()>(78, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setAutoDisplayEnabled'
        QtMocHelpers::SlotData<void(bool)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 73 },
        }}),
        // Slot 'setFlagHintsVisible'
        QtMocHelpers::SlotData<void(bool)>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagHintsVisible'
        QtMocHelpers::SlotData<bool()>(81, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagLabelsVisible'
        QtMocHelpers::SlotData<void(bool)>(82, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagLabelsVisible'
        QtMocHelpers::SlotData<bool()>(83, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagIconicMode'
        QtMocHelpers::SlotData<void(bool)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagIconicMode'
        QtMocHelpers::SlotData<bool()>(85, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getFlagHideInvisible'
        QtMocHelpers::SlotData<bool()>(86, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagHideInvisible'
        QtMocHelpers::SlotData<void(bool)>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagColoredInvisible'
        QtMocHelpers::SlotData<bool()>(88, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagColoredInvisible'
        QtMocHelpers::SlotData<void(bool)>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getInvisibleSatelliteColor'
        QtMocHelpers::SlotData<Vec3f()>(90, 2, QMC::AccessPublic, 0x80000000 | 23),
        // Slot 'setInvisibleSatelliteColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 92 },
        }}),
        // Slot 'getTransitSatelliteColor'
        QtMocHelpers::SlotData<Vec3f()>(93, 2, QMC::AccessPublic, 0x80000000 | 23),
        // Slot 'setTransitSatelliteColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 92 },
        }}),
        // Slot 'getLabelFontSize'
        QtMocHelpers::SlotData<int()>(95, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLabelFontSize'
        QtMocHelpers::SlotData<void(int)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 97 },
        }}),
        // Slot 'setUpdateFrequencyHours'
        QtMocHelpers::SlotData<void(int)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 99 },
        }}),
        // Slot 'updateFromOnlineSources'
        QtMocHelpers::SlotData<void()>(100, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setFlagOrbitLines'
        QtMocHelpers::SlotData<void(bool)>(101, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagOrbitLines'
        QtMocHelpers::SlotData<bool()>(102, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getOrbitLineSegments'
        QtMocHelpers::SlotData<int()>(103, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setOrbitLineSegments'
        QtMocHelpers::SlotData<void(int)>(104, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 6 },
        }}),
        // Slot 'getOrbitLineFadeSegments'
        QtMocHelpers::SlotData<int()>(105, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setOrbitLineFadeSegments'
        QtMocHelpers::SlotData<void(int)>(106, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 6 },
        }}),
        // Slot 'getOrbitLineThickness'
        QtMocHelpers::SlotData<int()>(107, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setOrbitLineThickness'
        QtMocHelpers::SlotData<void(int)>(108, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 6 },
        }}),
        // Slot 'getOrbitLineSegmentDuration'
        QtMocHelpers::SlotData<int()>(109, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setOrbitLineSegmentDuration'
        QtMocHelpers::SlotData<void(int)>(110, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 6 },
        }}),
        // Slot 'getTleEpochAgeDays'
        QtMocHelpers::SlotData<int()>(111, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setTleEpochAgeDays'
        QtMocHelpers::SlotData<void(int)>(112, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 113 },
        }}),
        // Slot 'recalculateOrbitLines'
        QtMocHelpers::SlotData<void()>(114, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setFlagUmbraVisible'
        QtMocHelpers::SlotData<void(bool)>(115, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagUmbraVisible'
        QtMocHelpers::SlotData<bool()>(116, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagUmbraAtFixedAltitude'
        QtMocHelpers::SlotData<void(bool)>(117, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagUmbraAtFixedAltitude'
        QtMocHelpers::SlotData<bool()>(118, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getUmbraColor'
        QtMocHelpers::SlotData<Vec3f()>(119, 2, QMC::AccessPublic, 0x80000000 | 23),
        // Slot 'setUmbraColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(120, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 92 },
        }}),
        // Slot 'getUmbraAltitude'
        QtMocHelpers::SlotData<double()>(121, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setUmbraAltitude'
        QtMocHelpers::SlotData<void(double)>(122, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 29 },
        }}),
        // Slot 'setFlagPenumbraVisible'
        QtMocHelpers::SlotData<void(bool)>(123, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagPenumbraVisible'
        QtMocHelpers::SlotData<bool()>(124, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getPenumbraColor'
        QtMocHelpers::SlotData<Vec3f()>(125, 2, QMC::AccessPublic, 0x80000000 | 23),
        // Slot 'setPenumbraColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(126, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 92 },
        }}),
        // Slot 'displayMessage'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(127, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 128 }, { QMetaType::QString, 129 },
        }}),
        // Slot 'displayMessage'
        QtMocHelpers::SlotData<void(const QString &)>(127, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 128 },
        }}),
        // Slot 'saveCatalog'
        QtMocHelpers::SlotData<void(const QString &)>(130, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 131 },
        }}),
        // Slot 'saveCatalog'
        QtMocHelpers::SlotData<void()>(130, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'setFlagCFKnownStdMagnitude'
        QtMocHelpers::SlotData<void(bool)>(132, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagCFKnownStdMagnitude'
        QtMocHelpers::SlotData<bool()>(133, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagCFApogee'
        QtMocHelpers::SlotData<void(bool)>(134, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagCFApogee'
        QtMocHelpers::SlotData<bool()>(135, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setMaxCFApogee'
        QtMocHelpers::SlotData<void(double)>(136, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMaxCFApogee'
        QtMocHelpers::SlotData<double()>(137, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setMinCFApogee'
        QtMocHelpers::SlotData<void(double)>(138, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMinCFApogee'
        QtMocHelpers::SlotData<double()>(139, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagCFPerigee'
        QtMocHelpers::SlotData<void(bool)>(140, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagCFPerigee'
        QtMocHelpers::SlotData<bool()>(141, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setMaxCFPerigee'
        QtMocHelpers::SlotData<void(double)>(142, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMaxCFPerigee'
        QtMocHelpers::SlotData<double()>(143, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setMinCFPerigee'
        QtMocHelpers::SlotData<void(double)>(144, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMinCFPerigee'
        QtMocHelpers::SlotData<double()>(145, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagVFAltitude'
        QtMocHelpers::SlotData<void(bool)>(146, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagVFAltitude'
        QtMocHelpers::SlotData<bool()>(147, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setMaxVFAltitude'
        QtMocHelpers::SlotData<void(double)>(148, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMaxVFAltitude'
        QtMocHelpers::SlotData<double()>(149, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setMinVFAltitude'
        QtMocHelpers::SlotData<void(double)>(150, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMinVFAltitude'
        QtMocHelpers::SlotData<double()>(151, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagVFMagnitude'
        QtMocHelpers::SlotData<void(bool)>(152, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagVFMagnitude'
        QtMocHelpers::SlotData<bool()>(153, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setMaxVFMagnitude'
        QtMocHelpers::SlotData<void(double)>(154, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMaxVFMagnitude'
        QtMocHelpers::SlotData<double()>(155, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setMinVFMagnitude'
        QtMocHelpers::SlotData<void(double)>(156, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMinVFMagnitude'
        QtMocHelpers::SlotData<double()>(157, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagCFEccentricity'
        QtMocHelpers::SlotData<void(bool)>(158, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagCFEccentricity'
        QtMocHelpers::SlotData<bool()>(159, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setMaxCFEccentricity'
        QtMocHelpers::SlotData<void(double)>(160, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMaxCFEccentricity'
        QtMocHelpers::SlotData<double()>(161, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setMinCFEccentricity'
        QtMocHelpers::SlotData<void(double)>(162, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMinCFEccentricity'
        QtMocHelpers::SlotData<double()>(163, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagCFPeriod'
        QtMocHelpers::SlotData<void(bool)>(164, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagCFPeriod'
        QtMocHelpers::SlotData<bool()>(165, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setMaxCFPeriod'
        QtMocHelpers::SlotData<void(double)>(166, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMaxCFPeriod'
        QtMocHelpers::SlotData<double()>(167, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setMinCFPeriod'
        QtMocHelpers::SlotData<void(double)>(168, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMinCFPeriod'
        QtMocHelpers::SlotData<double()>(169, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagCFInclination'
        QtMocHelpers::SlotData<void(bool)>(170, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagCFInclination'
        QtMocHelpers::SlotData<bool()>(171, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setMaxCFInclination'
        QtMocHelpers::SlotData<void(double)>(172, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMaxCFInclination'
        QtMocHelpers::SlotData<double()>(173, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setMinCFInclination'
        QtMocHelpers::SlotData<void(double)>(174, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMinCFInclination'
        QtMocHelpers::SlotData<double()>(175, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagCFRCS'
        QtMocHelpers::SlotData<void(bool)>(176, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagCFRCS'
        QtMocHelpers::SlotData<bool()>(177, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setMaxCFRCS'
        QtMocHelpers::SlotData<void(double)>(178, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMaxCFRCS'
        QtMocHelpers::SlotData<double()>(179, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setMinCFRCS'
        QtMocHelpers::SlotData<void(double)>(180, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 35 },
        }}),
        // Slot 'getMinCFRCS'
        QtMocHelpers::SlotData<double()>(181, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'updateSatellitesVisibility'
        QtMocHelpers::SlotData<void()>(182, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'saveSettings'
        QtMocHelpers::SlotData<void()>(183, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'translateData'
        QtMocHelpers::SlotData<void()>(184, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'checkForUpdate'
        QtMocHelpers::SlotData<void()>(185, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'saveDownloadedUpdate'
        QtMocHelpers::SlotData<void(QNetworkReply *)>(186, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 187, 188 },
        }}),
        // Slot 'updateObserverLocation'
        QtMocHelpers::SlotData<void(const StelLocation &)>(189, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 190, 191 },
        }}),
        // Slot 'changeSelectedSatellite'
        QtMocHelpers::SlotData<void(const QString &)>(192, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 193 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'flagHintsVisible'
        QtMocHelpers::PropertyData<bool>(194, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'flagLabelsVisible'
        QtMocHelpers::PropertyData<bool>(195, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'labelFontSize'
        QtMocHelpers::PropertyData<int>(196, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'autoAddEnabled'
        QtMocHelpers::PropertyData<bool>(197, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'autoRemoveEnabled'
        QtMocHelpers::PropertyData<bool>(198, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'autoDisplayEnabled'
        QtMocHelpers::PropertyData<bool>(199, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 11),
        // property 'flagIconicMode'
        QtMocHelpers::PropertyData<bool>(200, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'flagHideInvisible'
        QtMocHelpers::PropertyData<bool>(201, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'flagColoredInvisible'
        QtMocHelpers::PropertyData<bool>(202, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 6),
        // property 'flagOrbitLines'
        QtMocHelpers::PropertyData<bool>(203, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'updatesEnabled'
        QtMocHelpers::PropertyData<bool>(204, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 7),
        // property 'updateFrequencyHours'
        QtMocHelpers::PropertyData<int>(205, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'orbitLineSegments'
        QtMocHelpers::PropertyData<int>(206, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 12),
        // property 'orbitLineFadeSegments'
        QtMocHelpers::PropertyData<int>(207, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 13),
        // property 'orbitLineSegmentDuration'
        QtMocHelpers::PropertyData<int>(208, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'orbitLineThickness'
        QtMocHelpers::PropertyData<int>(209, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 14),
        // property 'tleEpochAgeDays'
        QtMocHelpers::PropertyData<int>(210, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'invisibleSatelliteColor'
        QtMocHelpers::PropertyData<Vec3f>(211, 0x80000000 | 23, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 17),
        // property 'transitSatelliteColor'
        QtMocHelpers::PropertyData<Vec3f>(212, 0x80000000 | 23, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 18),
        // property 'flagUmbraVisible'
        QtMocHelpers::PropertyData<bool>(213, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 19),
        // property 'flagUmbraAtFixedAltitude'
        QtMocHelpers::PropertyData<bool>(214, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 20),
        // property 'umbraAltitude'
        QtMocHelpers::PropertyData<double>(215, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 22),
        // property 'umbraColor'
        QtMocHelpers::PropertyData<Vec3f>(216, 0x80000000 | 23, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 21),
        // property 'flagPenumbraVisible'
        QtMocHelpers::PropertyData<bool>(217, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 23),
        // property 'penumbraColor'
        QtMocHelpers::PropertyData<Vec3f>(218, 0x80000000 | 23, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 24),
        // property 'flagCFKnownStdMagnitude'
        QtMocHelpers::PropertyData<bool>(219, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 25),
        // property 'flagCFApogee'
        QtMocHelpers::PropertyData<bool>(220, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 26),
        // property 'minCFApogee'
        QtMocHelpers::PropertyData<double>(221, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 27),
        // property 'maxCFApogee'
        QtMocHelpers::PropertyData<double>(222, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 28),
        // property 'flagCFPerigee'
        QtMocHelpers::PropertyData<bool>(223, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 29),
        // property 'minCFPerigee'
        QtMocHelpers::PropertyData<double>(224, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 30),
        // property 'maxCFPerigee'
        QtMocHelpers::PropertyData<double>(225, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 31),
        // property 'flagCFEccentricity'
        QtMocHelpers::PropertyData<bool>(226, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 32),
        // property 'minCFEccentricity'
        QtMocHelpers::PropertyData<double>(227, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 33),
        // property 'maxCFEccentricity'
        QtMocHelpers::PropertyData<double>(228, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 34),
        // property 'flagCFPeriod'
        QtMocHelpers::PropertyData<bool>(229, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 35),
        // property 'minCFPeriod'
        QtMocHelpers::PropertyData<double>(230, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 36),
        // property 'maxCFPeriod'
        QtMocHelpers::PropertyData<double>(231, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 37),
        // property 'flagCFInclination'
        QtMocHelpers::PropertyData<bool>(232, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 38),
        // property 'minCFInclination'
        QtMocHelpers::PropertyData<double>(233, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 39),
        // property 'maxCFInclination'
        QtMocHelpers::PropertyData<double>(234, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 40),
        // property 'flagCFRCS'
        QtMocHelpers::PropertyData<bool>(235, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 41),
        // property 'minCFRCS'
        QtMocHelpers::PropertyData<double>(236, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 42),
        // property 'maxCFRCS'
        QtMocHelpers::PropertyData<double>(237, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 43),
        // property 'flagVFAltitude'
        QtMocHelpers::PropertyData<bool>(238, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 44),
        // property 'minVFAltitude'
        QtMocHelpers::PropertyData<double>(239, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 45),
        // property 'maxVFAltitude'
        QtMocHelpers::PropertyData<double>(240, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 46),
        // property 'flagVFMagnitude'
        QtMocHelpers::PropertyData<bool>(241, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 47),
        // property 'minVFMagnitude'
        QtMocHelpers::PropertyData<double>(242, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 48),
        // property 'maxVFMagnitude'
        QtMocHelpers::PropertyData<double>(243, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 49),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Satellites, qt_meta_tag_ZN10SatellitesE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Satellites::staticMetaObject = { {
    QMetaObject::SuperData::link<StelObjectModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10SatellitesE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10SatellitesE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN10SatellitesE_t>.metaTypes,
    nullptr
} };

void Satellites::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Satellites *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->flagHintsVisibleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->flagLabelsVisibleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->labelFontSizeChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 3: _t->flagOrbitLinesChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 4: _t->flagIconicModeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 5: _t->flagHideInvisibleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->flagColoredInvisibleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->updatesEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 8: _t->updateFrequencyHoursChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 9: _t->autoAddEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 10: _t->autoRemoveEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 11: _t->autoDisplayEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 12: _t->orbitLineSegmentsChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 13: _t->orbitLineFadeSegmentsChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 14: _t->orbitLineThicknessChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 15: _t->orbitLineSegmentDurationChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 16: _t->tleEpochAgeDaysChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 17: _t->invisibleSatelliteColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 18: _t->transitSatelliteColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 19: _t->flagUmbraVisibleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 20: _t->flagUmbraAtFixedAltitudeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 21: _t->umbraColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 22: _t->umbraAltitudeChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 23: _t->flagPenumbraVisibleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 24: _t->penumbraColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 25: _t->flagCFKnownStdMagnitudeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 26: _t->flagCFApogeeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 27: _t->minCFApogeeChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 28: _t->maxCFApogeeChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 29: _t->flagCFPerigeeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 30: _t->minCFPerigeeChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 31: _t->maxCFPerigeeChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 32: _t->flagCFEccentricityChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 33: _t->minCFEccentricityChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 34: _t->maxCFEccentricityChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 35: _t->flagCFPeriodChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 36: _t->minCFPeriodChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 37: _t->maxCFPeriodChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 38: _t->flagCFInclinationChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 39: _t->minCFInclinationChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 40: _t->maxCFInclinationChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 41: _t->flagCFRCSChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 42: _t->minCFRCSChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 43: _t->maxCFRCSChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 44: _t->flagVFAltitudeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 45: _t->minVFAltitudeChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 46: _t->maxVFAltitudeChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 47: _t->flagVFMagnitudeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 48: _t->minVFMagnitudeChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 49: _t->maxVFMagnitudeChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 50: _t->settingsChanged(); break;
        case 51: _t->customFilterChanged(); break;
        case 52: _t->updateStateChanged((*reinterpret_cast<std::add_pointer_t<Satellites::UpdateState>>(_a[1]))); break;
        case 53: _t->tleUpdateComplete((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 54: _t->satGroupVisibleChanged(); break;
        case 55: _t->satSelectionChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 56: { bool _r = _t->getUpdatesEnabled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 57: _t->setUpdatesEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 58: { bool _r = _t->isAutoAddEnabled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 59: _t->setAutoAddEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 60: { bool _r = _t->isAutoRemoveEnabled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 61: _t->setAutoRemoveEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 62: { bool _r = _t->isAutoDisplayEnabled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 63: _t->setAutoDisplayEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 64: _t->setFlagHintsVisible((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 65: { bool _r = _t->getFlagHintsVisible();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 66: _t->setFlagLabelsVisible((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 67: { bool _r = _t->getFlagLabelsVisible();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 68: _t->setFlagIconicMode((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 69: { bool _r = _t->getFlagIconicMode();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 70: { bool _r = _t->getFlagHideInvisible();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 71: _t->setFlagHideInvisible((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 72: { bool _r = _t->getFlagColoredInvisible();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 73: _t->setFlagColoredInvisible((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 74: { Vec3f _r = _t->getInvisibleSatelliteColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 75: _t->setInvisibleSatelliteColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 76: { Vec3f _r = _t->getTransitSatelliteColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 77: _t->setTransitSatelliteColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 78: { int _r = _t->getLabelFontSize();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 79: _t->setLabelFontSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 80: _t->setUpdateFrequencyHours((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 81: _t->updateFromOnlineSources(); break;
        case 82: _t->setFlagOrbitLines((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 83: { bool _r = _t->getFlagOrbitLines();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 84: { int _r = _t->getOrbitLineSegments();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 85: _t->setOrbitLineSegments((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 86: { int _r = _t->getOrbitLineFadeSegments();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 87: _t->setOrbitLineFadeSegments((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 88: { int _r = _t->getOrbitLineThickness();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 89: _t->setOrbitLineThickness((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 90: { int _r = _t->getOrbitLineSegmentDuration();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 91: _t->setOrbitLineSegmentDuration((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 92: { int _r = _t->getTleEpochAgeDays();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 93: _t->setTleEpochAgeDays((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 94: _t->recalculateOrbitLines(); break;
        case 95: _t->setFlagUmbraVisible((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 96: { bool _r = _t->getFlagUmbraVisible();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 97: _t->setFlagUmbraAtFixedAltitude((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 98: { bool _r = _t->getFlagUmbraAtFixedAltitude();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 99: { Vec3f _r = _t->getUmbraColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 100: _t->setUmbraColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 101: { double _r = _t->getUmbraAltitude();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 102: _t->setUmbraAltitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 103: _t->setFlagPenumbraVisible((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 104: { bool _r = _t->getFlagPenumbraVisible();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 105: { Vec3f _r = _t->getPenumbraColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 106: _t->setPenumbraColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 107: _t->displayMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 108: _t->displayMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 109: _t->saveCatalog((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 110: _t->saveCatalog(); break;
        case 111: _t->setFlagCFKnownStdMagnitude((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 112: { bool _r = _t->getFlagCFKnownStdMagnitude();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 113: _t->setFlagCFApogee((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 114: { bool _r = _t->getFlagCFApogee();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 115: _t->setMaxCFApogee((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 116: { double _r = _t->getMaxCFApogee();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 117: _t->setMinCFApogee((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 118: { double _r = _t->getMinCFApogee();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 119: _t->setFlagCFPerigee((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 120: { bool _r = _t->getFlagCFPerigee();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 121: _t->setMaxCFPerigee((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 122: { double _r = _t->getMaxCFPerigee();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 123: _t->setMinCFPerigee((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 124: { double _r = _t->getMinCFPerigee();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 125: _t->setFlagVFAltitude((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 126: { bool _r = _t->getFlagVFAltitude();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 127: _t->setMaxVFAltitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 128: { double _r = _t->getMaxVFAltitude();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 129: _t->setMinVFAltitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 130: { double _r = _t->getMinVFAltitude();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 131: _t->setFlagVFMagnitude((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 132: { bool _r = _t->getFlagVFMagnitude();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 133: _t->setMaxVFMagnitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 134: { double _r = _t->getMaxVFMagnitude();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 135: _t->setMinVFMagnitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 136: { double _r = _t->getMinVFMagnitude();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 137: _t->setFlagCFEccentricity((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 138: { bool _r = _t->getFlagCFEccentricity();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 139: _t->setMaxCFEccentricity((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 140: { double _r = _t->getMaxCFEccentricity();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 141: _t->setMinCFEccentricity((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 142: { double _r = _t->getMinCFEccentricity();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 143: _t->setFlagCFPeriod((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 144: { bool _r = _t->getFlagCFPeriod();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 145: _t->setMaxCFPeriod((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 146: { double _r = _t->getMaxCFPeriod();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 147: _t->setMinCFPeriod((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 148: { double _r = _t->getMinCFPeriod();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 149: _t->setFlagCFInclination((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 150: { bool _r = _t->getFlagCFInclination();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 151: _t->setMaxCFInclination((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 152: { double _r = _t->getMaxCFInclination();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 153: _t->setMinCFInclination((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 154: { double _r = _t->getMinCFInclination();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 155: _t->setFlagCFRCS((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 156: { bool _r = _t->getFlagCFRCS();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 157: _t->setMaxCFRCS((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 158: { double _r = _t->getMaxCFRCS();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 159: _t->setMinCFRCS((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 160: { double _r = _t->getMinCFRCS();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 161: _t->updateSatellitesVisibility(); break;
        case 162: _t->saveSettings(); break;
        case 163: _t->translateData(); break;
        case 164: _t->checkForUpdate(); break;
        case 165: _t->saveDownloadedUpdate((*reinterpret_cast<std::add_pointer_t<QNetworkReply*>>(_a[1]))); break;
        case 166: _t->updateObserverLocation((*reinterpret_cast<std::add_pointer_t<StelLocation>>(_a[1]))); break;
        case 167: _t->changeSelectedSatellite((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 17:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 18:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 21:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 24:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 75:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 77:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 100:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 106:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 166:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelLocation >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagHintsVisibleChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagLabelsVisibleChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(int )>(_a, &Satellites::labelFontSizeChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagOrbitLinesChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagIconicModeChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagHideInvisibleChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagColoredInvisibleChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::updatesEnabledChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(int )>(_a, &Satellites::updateFrequencyHoursChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::autoAddEnabledChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::autoRemoveEnabledChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::autoDisplayEnabledChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(int )>(_a, &Satellites::orbitLineSegmentsChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(int )>(_a, &Satellites::orbitLineFadeSegmentsChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(int )>(_a, &Satellites::orbitLineThicknessChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(int )>(_a, &Satellites::orbitLineSegmentDurationChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(int )>(_a, &Satellites::tleEpochAgeDaysChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(Vec3f )>(_a, &Satellites::invisibleSatelliteColorChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(Vec3f )>(_a, &Satellites::transitSatelliteColorChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagUmbraVisibleChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagUmbraAtFixedAltitudeChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(Vec3f )>(_a, &Satellites::umbraColorChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::umbraAltitudeChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagPenumbraVisibleChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(Vec3f )>(_a, &Satellites::penumbraColorChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagCFKnownStdMagnitudeChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagCFApogeeChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::minCFApogeeChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::maxCFApogeeChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagCFPerigeeChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::minCFPerigeeChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::maxCFPerigeeChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagCFEccentricityChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::minCFEccentricityChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::maxCFEccentricityChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagCFPeriodChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::minCFPeriodChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::maxCFPeriodChanged, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagCFInclinationChanged, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::minCFInclinationChanged, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::maxCFInclinationChanged, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagCFRCSChanged, 41))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::minCFRCSChanged, 42))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::maxCFRCSChanged, 43))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagVFAltitudeChanged, 44))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::minVFAltitudeChanged, 45))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::maxVFAltitudeChanged, 46))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(bool )>(_a, &Satellites::flagVFMagnitudeChanged, 47))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::minVFMagnitudeChanged, 48))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(double )>(_a, &Satellites::maxVFMagnitudeChanged, 49))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)()>(_a, &Satellites::settingsChanged, 50))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)()>(_a, &Satellites::customFilterChanged, 51))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(Satellites::UpdateState )>(_a, &Satellites::updateStateChanged, 52))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(int , int , int , int )>(_a, &Satellites::tleUpdateComplete, 53))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)()>(_a, &Satellites::satGroupVisibleChanged, 54))
            return;
        if (QtMocHelpers::indexOfMethod<void (Satellites::*)(const QString & )>(_a, &Satellites::satSelectionChanged, 55))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 24:
        case 22:
        case 18:
        case 17:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Vec3f >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->getFlagHintsVisible(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->getFlagLabelsVisible(); break;
        case 2: *reinterpret_cast<int*>(_v) = _t->getLabelFontSize(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->isAutoAddEnabled(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->isAutoRemoveEnabled(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->isAutoDisplayEnabled(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->getFlagIconicMode(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->getFlagHideInvisible(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->getFlagColoredInvisible(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->getFlagOrbitLines(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->getUpdatesEnabled(); break;
        case 11: *reinterpret_cast<int*>(_v) = _t->getUpdateFrequencyHours(); break;
        case 12: *reinterpret_cast<int*>(_v) = _t->getOrbitLineSegments(); break;
        case 13: *reinterpret_cast<int*>(_v) = _t->getOrbitLineFadeSegments(); break;
        case 14: *reinterpret_cast<int*>(_v) = _t->getOrbitLineSegmentDuration(); break;
        case 15: *reinterpret_cast<int*>(_v) = _t->getOrbitLineThickness(); break;
        case 16: *reinterpret_cast<int*>(_v) = _t->getTleEpochAgeDays(); break;
        case 17: *reinterpret_cast<Vec3f*>(_v) = _t->getInvisibleSatelliteColor(); break;
        case 18: *reinterpret_cast<Vec3f*>(_v) = _t->getTransitSatelliteColor(); break;
        case 19: *reinterpret_cast<bool*>(_v) = _t->getFlagUmbraVisible(); break;
        case 20: *reinterpret_cast<bool*>(_v) = _t->getFlagUmbraAtFixedAltitude(); break;
        case 21: *reinterpret_cast<double*>(_v) = _t->getUmbraAltitude(); break;
        case 22: *reinterpret_cast<Vec3f*>(_v) = _t->getUmbraColor(); break;
        case 23: *reinterpret_cast<bool*>(_v) = _t->getFlagPenumbraVisible(); break;
        case 24: *reinterpret_cast<Vec3f*>(_v) = _t->getPenumbraColor(); break;
        case 25: *reinterpret_cast<bool*>(_v) = _t->getFlagCFKnownStdMagnitude(); break;
        case 26: *reinterpret_cast<bool*>(_v) = _t->getFlagCFApogee(); break;
        case 27: *reinterpret_cast<double*>(_v) = _t->getMinCFApogee(); break;
        case 28: *reinterpret_cast<double*>(_v) = _t->getMaxCFApogee(); break;
        case 29: *reinterpret_cast<bool*>(_v) = _t->getFlagCFPerigee(); break;
        case 30: *reinterpret_cast<double*>(_v) = _t->getMinCFPerigee(); break;
        case 31: *reinterpret_cast<double*>(_v) = _t->getMaxCFPerigee(); break;
        case 32: *reinterpret_cast<bool*>(_v) = _t->getFlagCFEccentricity(); break;
        case 33: *reinterpret_cast<double*>(_v) = _t->getMinCFEccentricity(); break;
        case 34: *reinterpret_cast<double*>(_v) = _t->getMaxCFEccentricity(); break;
        case 35: *reinterpret_cast<bool*>(_v) = _t->getFlagCFPeriod(); break;
        case 36: *reinterpret_cast<double*>(_v) = _t->getMinCFPeriod(); break;
        case 37: *reinterpret_cast<double*>(_v) = _t->getMaxCFPeriod(); break;
        case 38: *reinterpret_cast<bool*>(_v) = _t->getFlagCFInclination(); break;
        case 39: *reinterpret_cast<double*>(_v) = _t->getMinCFInclination(); break;
        case 40: *reinterpret_cast<double*>(_v) = _t->getMaxCFInclination(); break;
        case 41: *reinterpret_cast<bool*>(_v) = _t->getFlagCFRCS(); break;
        case 42: *reinterpret_cast<double*>(_v) = _t->getMinCFRCS(); break;
        case 43: *reinterpret_cast<double*>(_v) = _t->getMaxCFRCS(); break;
        case 44: *reinterpret_cast<bool*>(_v) = _t->getFlagVFAltitude(); break;
        case 45: *reinterpret_cast<double*>(_v) = _t->getMinVFAltitude(); break;
        case 46: *reinterpret_cast<double*>(_v) = _t->getMaxVFAltitude(); break;
        case 47: *reinterpret_cast<bool*>(_v) = _t->getFlagVFMagnitude(); break;
        case 48: *reinterpret_cast<double*>(_v) = _t->getMinVFMagnitude(); break;
        case 49: *reinterpret_cast<double*>(_v) = _t->getMaxVFMagnitude(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFlagHintsVisible(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setFlagLabelsVisible(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setLabelFontSize(*reinterpret_cast<int*>(_v)); break;
        case 3: _t->setAutoAddEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 4: _t->setAutoRemoveEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 5: _t->setAutoDisplayEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 6: _t->setFlagIconicMode(*reinterpret_cast<bool*>(_v)); break;
        case 7: _t->setFlagHideInvisible(*reinterpret_cast<bool*>(_v)); break;
        case 8: _t->setFlagColoredInvisible(*reinterpret_cast<bool*>(_v)); break;
        case 9: _t->setFlagOrbitLines(*reinterpret_cast<bool*>(_v)); break;
        case 10: _t->setUpdatesEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 11: _t->setUpdateFrequencyHours(*reinterpret_cast<int*>(_v)); break;
        case 12: _t->setOrbitLineSegments(*reinterpret_cast<int*>(_v)); break;
        case 13: _t->setOrbitLineFadeSegments(*reinterpret_cast<int*>(_v)); break;
        case 14: _t->setOrbitLineSegmentDuration(*reinterpret_cast<int*>(_v)); break;
        case 15: _t->setOrbitLineThickness(*reinterpret_cast<int*>(_v)); break;
        case 16: _t->setTleEpochAgeDays(*reinterpret_cast<int*>(_v)); break;
        case 17: _t->setInvisibleSatelliteColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 18: _t->setTransitSatelliteColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 19: _t->setFlagUmbraVisible(*reinterpret_cast<bool*>(_v)); break;
        case 20: _t->setFlagUmbraAtFixedAltitude(*reinterpret_cast<bool*>(_v)); break;
        case 21: _t->setUmbraAltitude(*reinterpret_cast<double*>(_v)); break;
        case 22: _t->setUmbraColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 23: _t->setFlagPenumbraVisible(*reinterpret_cast<bool*>(_v)); break;
        case 24: _t->setPenumbraColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 25: _t->setFlagCFKnownStdMagnitude(*reinterpret_cast<bool*>(_v)); break;
        case 26: _t->setFlagCFApogee(*reinterpret_cast<bool*>(_v)); break;
        case 27: _t->setMinCFApogee(*reinterpret_cast<double*>(_v)); break;
        case 28: _t->setMaxCFApogee(*reinterpret_cast<double*>(_v)); break;
        case 29: _t->setFlagCFPerigee(*reinterpret_cast<bool*>(_v)); break;
        case 30: _t->setMinCFPerigee(*reinterpret_cast<double*>(_v)); break;
        case 31: _t->setMaxCFPerigee(*reinterpret_cast<double*>(_v)); break;
        case 32: _t->setFlagCFEccentricity(*reinterpret_cast<bool*>(_v)); break;
        case 33: _t->setMinCFEccentricity(*reinterpret_cast<double*>(_v)); break;
        case 34: _t->setMaxCFEccentricity(*reinterpret_cast<double*>(_v)); break;
        case 35: _t->setFlagCFPeriod(*reinterpret_cast<bool*>(_v)); break;
        case 36: _t->setMinCFPeriod(*reinterpret_cast<double*>(_v)); break;
        case 37: _t->setMaxCFPeriod(*reinterpret_cast<double*>(_v)); break;
        case 38: _t->setFlagCFInclination(*reinterpret_cast<bool*>(_v)); break;
        case 39: _t->setMinCFInclination(*reinterpret_cast<double*>(_v)); break;
        case 40: _t->setMaxCFInclination(*reinterpret_cast<double*>(_v)); break;
        case 41: _t->setFlagCFRCS(*reinterpret_cast<bool*>(_v)); break;
        case 42: _t->setMinCFRCS(*reinterpret_cast<double*>(_v)); break;
        case 43: _t->setMaxCFRCS(*reinterpret_cast<double*>(_v)); break;
        case 44: _t->setFlagVFAltitude(*reinterpret_cast<bool*>(_v)); break;
        case 45: _t->setMinVFAltitude(*reinterpret_cast<double*>(_v)); break;
        case 46: _t->setMaxVFAltitude(*reinterpret_cast<double*>(_v)); break;
        case 47: _t->setFlagVFMagnitude(*reinterpret_cast<bool*>(_v)); break;
        case 48: _t->setMinVFMagnitude(*reinterpret_cast<double*>(_v)); break;
        case 49: _t->setMaxVFMagnitude(*reinterpret_cast<double*>(_v)); break;
        default: break;
        }
    }
}

const QMetaObject *Satellites::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Satellites::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10SatellitesE_t>.strings))
        return static_cast<void*>(this);
    return StelObjectModule::qt_metacast(_clname);
}

int Satellites::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = StelObjectModule::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 168)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 168;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 168)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 168;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 50;
    }
    return _id;
}

// SIGNAL 0
void Satellites::flagHintsVisibleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void Satellites::flagLabelsVisibleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void Satellites::labelFontSizeChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void Satellites::flagOrbitLinesChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void Satellites::flagIconicModeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void Satellites::flagHideInvisibleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void Satellites::flagColoredInvisibleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void Satellites::updatesEnabledChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void Satellites::updateFrequencyHoursChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void Satellites::autoAddEnabledChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void Satellites::autoRemoveEnabledChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void Satellites::autoDisplayEnabledChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void Satellites::orbitLineSegmentsChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void Satellites::orbitLineFadeSegmentsChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void Satellites::orbitLineThicknessChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void Satellites::orbitLineSegmentDurationChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void Satellites::tleEpochAgeDaysChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void Satellites::invisibleSatelliteColorChanged(Vec3f _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void Satellites::transitSatelliteColorChanged(Vec3f _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void Satellites::flagUmbraVisibleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void Satellites::flagUmbraAtFixedAltitudeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void Satellites::umbraColorChanged(Vec3f _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void Satellites::umbraAltitudeChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void Satellites::flagPenumbraVisibleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void Satellites::penumbraColorChanged(Vec3f _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void Satellites::flagCFKnownStdMagnitudeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void Satellites::flagCFApogeeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void Satellites::minCFApogeeChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}

// SIGNAL 28
void Satellites::maxCFApogeeChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void Satellites::flagCFPerigeeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1);
}

// SIGNAL 30
void Satellites::minCFPerigeeChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void Satellites::maxCFPerigeeChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1);
}

// SIGNAL 32
void Satellites::flagCFEccentricityChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 32, nullptr, _t1);
}

// SIGNAL 33
void Satellites::minCFEccentricityChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1);
}

// SIGNAL 34
void Satellites::maxCFEccentricityChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void Satellites::flagCFPeriodChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1);
}

// SIGNAL 36
void Satellites::minCFPeriodChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 36, nullptr, _t1);
}

// SIGNAL 37
void Satellites::maxCFPeriodChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 37, nullptr, _t1);
}

// SIGNAL 38
void Satellites::flagCFInclinationChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 38, nullptr, _t1);
}

// SIGNAL 39
void Satellites::minCFInclinationChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 39, nullptr, _t1);
}

// SIGNAL 40
void Satellites::maxCFInclinationChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 40, nullptr, _t1);
}

// SIGNAL 41
void Satellites::flagCFRCSChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 41, nullptr, _t1);
}

// SIGNAL 42
void Satellites::minCFRCSChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 42, nullptr, _t1);
}

// SIGNAL 43
void Satellites::maxCFRCSChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 43, nullptr, _t1);
}

// SIGNAL 44
void Satellites::flagVFAltitudeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 44, nullptr, _t1);
}

// SIGNAL 45
void Satellites::minVFAltitudeChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 45, nullptr, _t1);
}

// SIGNAL 46
void Satellites::maxVFAltitudeChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 46, nullptr, _t1);
}

// SIGNAL 47
void Satellites::flagVFMagnitudeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 47, nullptr, _t1);
}

// SIGNAL 48
void Satellites::minVFMagnitudeChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 48, nullptr, _t1);
}

// SIGNAL 49
void Satellites::maxVFMagnitudeChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 49, nullptr, _t1);
}

// SIGNAL 50
void Satellites::settingsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 50, nullptr);
}

// SIGNAL 51
void Satellites::customFilterChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 51, nullptr);
}

// SIGNAL 52
void Satellites::updateStateChanged(Satellites::UpdateState _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 52, nullptr, _t1);
}

// SIGNAL 53
void Satellites::tleUpdateComplete(int _t1, int _t2, int _t3, int _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 53, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 54
void Satellites::satGroupVisibleChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 54, nullptr);
}

// SIGNAL 55
void Satellites::satSelectionChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 55, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN29SatellitesStelPluginInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto SatellitesStelPluginInterface::qt_create_metaobjectdata<qt_meta_tag_ZN29SatellitesStelPluginInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "SatellitesStelPluginInterface"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<SatellitesStelPluginInterface, qt_meta_tag_ZN29SatellitesStelPluginInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject SatellitesStelPluginInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29SatellitesStelPluginInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29SatellitesStelPluginInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN29SatellitesStelPluginInterfaceE_t>.metaTypes,
    nullptr
} };

void SatellitesStelPluginInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<SatellitesStelPluginInterface *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *SatellitesStelPluginInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *SatellitesStelPluginInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29SatellitesStelPluginInterfaceE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "StelPluginInterface"))
        return static_cast< StelPluginInterface*>(this);
    if (!strcmp(_clname, "org.stellarium.StelPluginInterface/2.0"))
        return static_cast< StelPluginInterface*>(this);
    return QObject::qt_metacast(_clname);
}

int SatellitesStelPluginInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}

#ifdef QT_MOC_EXPORT_PLUGIN_V2
static constexpr unsigned char qt_pluginMetaDataV2_SatellitesStelPluginInterface[] = {
    0xbf, 
    // "IID"
    0x02,  0x78,  0x26,  'o',  'r',  'g',  '.',  's', 
    't',  'e',  'l',  'l',  'a',  'r',  'i',  'u', 
    'm',  '.',  'S',  't',  'e',  'l',  'P',  'l', 
    'u',  'g',  'i',  'n',  'I',  'n',  't',  'e', 
    'r',  'f',  'a',  'c',  'e',  '/',  '2',  '.', 
    '0', 
    // "className"
    0x03,  0x78,  0x1d,  'S',  'a',  't',  'e',  'l', 
    'l',  'i',  't',  'e',  's',  'S',  't',  'e', 
    'l',  'P',  'l',  'u',  'g',  'i',  'n',  'I', 
    'n',  't',  'e',  'r',  'f',  'a',  'c',  'e', 
    0xff, 
};
QT_MOC_EXPORT_PLUGIN_V2(SatellitesStelPluginInterface, SatellitesStelPluginInterface, qt_pluginMetaDataV2_SatellitesStelPluginInterface)
#else
QT_PLUGIN_METADATA_SECTION
Q_CONSTINIT static constexpr unsigned char qt_pluginMetaData_SatellitesStelPluginInterface[] = {
    'Q', 'T', 'M', 'E', 'T', 'A', 'D', 'A', 'T', 'A', ' ', '!',
    // metadata version, Qt version, architectural requirements
    0, QT_VERSION_MAJOR, QT_VERSION_MINOR, qPluginArchRequirements(),
    0xbf, 
    // "IID"
    0x02,  0x78,  0x26,  'o',  'r',  'g',  '.',  's', 
    't',  'e',  'l',  'l',  'a',  'r',  'i',  'u', 
    'm',  '.',  'S',  't',  'e',  'l',  'P',  'l', 
    'u',  'g',  'i',  'n',  'I',  'n',  't',  'e', 
    'r',  'f',  'a',  'c',  'e',  '/',  '2',  '.', 
    '0', 
    // "className"
    0x03,  0x78,  0x1d,  'S',  'a',  't',  'e',  'l', 
    'l',  'i',  't',  'e',  's',  'S',  't',  'e', 
    'l',  'P',  'l',  'u',  'g',  'i',  'n',  'I', 
    'n',  't',  'e',  'r',  'f',  'a',  'c',  'e', 
    0xff, 
};
QT_MOC_EXPORT_PLUGIN(SatellitesStelPluginInterface, SatellitesStelPluginInterface)
#endif  // QT_MOC_EXPORT_PLUGIN_V2

QT_WARNING_POP
