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

#include "../../../../../kpublictransport-26.07.90/src/qmlplugin/kpublictransportqmlplugin.h"
#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 'kpublictransportqmlplugin.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.12.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_ZN18AttributionForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto AttributionForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18AttributionForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "AttributionForeign",
        "QML.Foreign",
        "KPublicTransport::Attribution",
        "QML.Element",
        "attribution",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "only provided from C++ API"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<AttributionForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject AttributionForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18AttributionForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18AttributionForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18AttributionForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN14BackendForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto BackendForeign::qt_create_metaobjectdata<qt_meta_tag_ZN14BackendForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "BackendForeign",
        "QML.Foreign",
        "KPublicTransport::Backend",
        "QML.Element",
        "backend"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<BackendForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject BackendForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14BackendForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14BackendForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14BackendForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN19BackendModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto BackendModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN19BackendModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "BackendModelForeign",
        "QML.Foreign",
        "KPublicTransport::BackendModel",
        "QML.Element",
        "BackendModel"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<BackendModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject BackendModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19BackendModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19BackendModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19BackendModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN12CoverageAreaE_t {};
} // unnamed namespace

template <> constexpr inline auto CoverageArea::qt_create_metaobjectdata<qt_meta_tag_ZN12CoverageAreaE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CoverageArea",
        "QML.Foreign",
        "KPublicTransport::CoverageArea",
        "QML.Element",
        "coverageArea"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<CoverageArea, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject CoverageArea::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12CoverageAreaE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12CoverageAreaE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12CoverageAreaE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN19CoverageAreaDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CoverageAreaDerived, qt_meta_tag_ZN19CoverageAreaDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject CoverageAreaDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::CoverageArea>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19CoverageAreaDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19CoverageAreaDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19CoverageAreaDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN27CoverageCountryModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto CoverageCountryModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN27CoverageCountryModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CoverageCountryModelForeign",
        "QML.Foreign",
        "KPublicTransport::CoverageCountryModel",
        "QML.Element",
        "CoverageCountryModel"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<CoverageCountryModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject CoverageCountryModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27CoverageCountryModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27CoverageCountryModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27CoverageCountryModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN16EquipmentForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto EquipmentForeign::qt_create_metaobjectdata<qt_meta_tag_ZN16EquipmentForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "EquipmentForeign",
        "QML.Foreign",
        "KPublicTransport::Equipment",
        "QML.Element",
        "equipment"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<EquipmentForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject EquipmentForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16EquipmentForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16EquipmentForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16EquipmentForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN16EquipmentDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<EquipmentDerived, qt_meta_tag_ZN16EquipmentDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject EquipmentDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::Equipment>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16EquipmentDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16EquipmentDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16EquipmentDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN14FeatureForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto FeatureForeign::qt_create_metaobjectdata<qt_meta_tag_ZN14FeatureForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "FeatureForeign",
        "QML.Foreign",
        "KPublicTransport::Feature",
        "QML.Element",
        "feature",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "only provided from C++ API"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<FeatureForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject FeatureForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14FeatureForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14FeatureForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14FeatureForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN14FeatureDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<FeatureDerived, qt_meta_tag_ZN14FeatureDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject FeatureDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::Feature>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14FeatureDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14FeatureDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14FeatureDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN11FeatureTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto FeatureType::qt_create_metaobjectdata<qt_meta_tag_ZN11FeatureTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "FeatureType",
        "QML.Element",
        "anonymous",
        "typeIconName",
        "",
        "KPublicTransport::Feature::Type",
        "type"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'typeIconName'
        QtMocHelpers::MethodData<QString(KPublicTransport::Feature::Type)>(3, 4, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 5, 6 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<FeatureType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject FeatureType::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11FeatureTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11FeatureTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11FeatureTypeE_t>.metaTypes,
    nullptr
} };

void FeatureType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<FeatureType *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->typeIconName((*reinterpret_cast<std::add_pointer_t<KPublicTransport::Feature::Type>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}
namespace {
struct qt_meta_tag_ZN26IndividualTransportForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto IndividualTransportForeign::qt_create_metaobjectdata<qt_meta_tag_ZN26IndividualTransportForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "IndividualTransportForeign",
        "QML.Foreign",
        "KPublicTransport::IndividualTransport",
        "QML.Element",
        "individualTransport",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<IndividualTransportForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject IndividualTransportForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26IndividualTransportForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26IndividualTransportForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26IndividualTransportForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN26IndividualTransportDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<IndividualTransportDerived, qt_meta_tag_ZN26IndividualTransportDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject IndividualTransportDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::IndividualTransport>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26IndividualTransportDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26IndividualTransportDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26IndividualTransportDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN14JourneyForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto JourneyForeign::qt_create_metaobjectdata<qt_meta_tag_ZN14JourneyForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JourneyForeign",
        "QML.Foreign",
        "KPublicTransport::Journey",
        "QML.Element",
        "journey",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<JourneyForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject JourneyForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14JourneyForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14JourneyForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14JourneyForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21JourneyRequestForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto JourneyRequestForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21JourneyRequestForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JourneyRequestForeign",
        "QML.Foreign",
        "KPublicTransport::JourneyRequest",
        "QML.Element",
        "journeyRequest",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<JourneyRequestForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject JourneyRequestForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21JourneyRequestForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21JourneyRequestForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21JourneyRequestForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21JourneyRequestDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<JourneyRequestDerived, qt_meta_tag_ZN21JourneyRequestDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject JourneyRequestDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::JourneyRequest>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21JourneyRequestDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21JourneyRequestDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21JourneyRequestDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN24JourneyQueryModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto JourneyQueryModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN24JourneyQueryModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JourneyQueryModelForeign",
        "QML.Foreign",
        "KPublicTransport::JourneyQueryModel",
        "QML.Element",
        "JourneyQueryModel"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<JourneyQueryModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject JourneyQueryModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24JourneyQueryModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24JourneyQueryModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24JourneyQueryModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21JourneySectionForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto JourneySectionForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21JourneySectionForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JourneySectionForeign",
        "QML.Foreign",
        "KPublicTransport::JourneySection",
        "QML.Element",
        "journeySection",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<JourneySectionForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject JourneySectionForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21JourneySectionForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21JourneySectionForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21JourneySectionForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21JourneySectionDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<JourneySectionDerived, qt_meta_tag_ZN21JourneySectionDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject JourneySectionDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::JourneySection>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21JourneySectionDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21JourneySectionDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21JourneySectionDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN11LineForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto LineForeign::qt_create_metaobjectdata<qt_meta_tag_ZN11LineForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LineForeign",
        "QML.Foreign",
        "KPublicTransport::Line",
        "QML.Element",
        "line",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<LineForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject LineForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11LineForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11LineForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11LineForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN11LineDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<LineDerived, qt_meta_tag_ZN11LineDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject LineDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::Line>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11LineDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11LineDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11LineDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN8LineModeE_t {};
} // unnamed namespace

template <> constexpr inline auto LineMode::qt_create_metaobjectdata<qt_meta_tag_ZN8LineModeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LineMode",
        "QML.Element",
        "anonymous",
        "iconName",
        "",
        "KPublicTransport::Line::Mode",
        "mode"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'iconName'
        QtMocHelpers::MethodData<QString(KPublicTransport::Line::Mode)>(3, 4, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 5, 6 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<LineMode, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject LineMode::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8LineModeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8LineModeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8LineModeE_t>.metaTypes,
    nullptr
} };

void LineMode::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<LineMode *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->iconName((*reinterpret_cast<std::add_pointer_t<KPublicTransport::Line::Mode>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}
namespace {
struct qt_meta_tag_ZN15LoadInfoForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto LoadInfoForeign::qt_create_metaobjectdata<qt_meta_tag_ZN15LoadInfoForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LoadInfoForeign",
        "QML.Foreign",
        "KPublicTransport::LoadInfo",
        "QML.Element",
        "loadInfo",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<LoadInfoForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject LoadInfoForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15LoadInfoForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15LoadInfoForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15LoadInfoForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN15LocationForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto LocationForeign::qt_create_metaobjectdata<qt_meta_tag_ZN15LocationForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LocationForeign",
        "QML.Foreign",
        "KPublicTransport::Location",
        "QML.Element",
        "location",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<LocationForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject LocationForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15LocationForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15LocationForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15LocationForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN15LocationDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<LocationDerived, qt_meta_tag_ZN15LocationDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject LocationDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::Location>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15LocationDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15LocationDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15LocationDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN27LocationHistoryModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto LocationHistoryModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN27LocationHistoryModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LocationHistoryModelForeign",
        "QML.Foreign",
        "KPublicTransport::LocationHistoryModel",
        "QML.Element",
        "LocationHistoryModel"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<LocationHistoryModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject LocationHistoryModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27LocationHistoryModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27LocationHistoryModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27LocationHistoryModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22LocationRequestForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto LocationRequestForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22LocationRequestForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LocationRequestForeign",
        "QML.Foreign",
        "KPublicTransport::LocationRequest",
        "QML.Element",
        "locationRequest",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<LocationRequestForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject LocationRequestForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22LocationRequestForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22LocationRequestForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22LocationRequestForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22LocationRequestDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<LocationRequestDerived, qt_meta_tag_ZN22LocationRequestDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject LocationRequestDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::LocationRequest>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22LocationRequestDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22LocationRequestDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22LocationRequestDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN25LocationQueryModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto LocationQueryModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN25LocationQueryModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LocationQueryModelForeign",
        "QML.Foreign",
        "KPublicTransport::LocationQueryModel",
        "QML.Element",
        "LocationQueryModel"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<LocationQueryModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject LocationQueryModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25LocationQueryModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25LocationQueryModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN25LocationQueryModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN14ManagerForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto ManagerForeign::qt_create_metaobjectdata<qt_meta_tag_ZN14ManagerForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ManagerForeign",
        "QML.Foreign",
        "KPublicTransport::Manager",
        "QML.Element",
        "Manager"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<ManagerForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject ManagerForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ManagerForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ManagerForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14ManagerForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN11PathForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto PathForeign::qt_create_metaobjectdata<qt_meta_tag_ZN11PathForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PathForeign",
        "QML.Foreign",
        "KPublicTransport::Path",
        "QML.Element",
        "path"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<PathForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject PathForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11PathForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11PathForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11PathForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN16PathModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto PathModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN16PathModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PathModelForeign",
        "QML.Foreign",
        "KPublicTransport::PathModel",
        "QML.Element",
        "PathModel"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<PathModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject PathModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16PathModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16PathModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16PathModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18PathSectionForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto PathSectionForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18PathSectionForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PathSectionForeign",
        "QML.Foreign",
        "KPublicTransport::PathSection",
        "QML.Element",
        "pathSection"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<PathSectionForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject PathSectionForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18PathSectionForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18PathSectionForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18PathSectionForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18PathSectionDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PathSectionDerived, qt_meta_tag_ZN18PathSectionDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject PathSectionDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::PathSection>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18PathSectionDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18PathSectionDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18PathSectionDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN15PlatformForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto PlatformForeign::qt_create_metaobjectdata<qt_meta_tag_ZN15PlatformForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PlatformForeign",
        "QML.Foreign",
        "KPublicTransport::Platform",
        "QML.Element",
        "platform"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<PlatformForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject PlatformForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15PlatformForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15PlatformForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15PlatformForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22PlatformSectionForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto PlatformSectionForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22PlatformSectionForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PlatformSectionForeign",
        "QML.Foreign",
        "KPublicTransport::PlatformSection",
        "QML.Element",
        "platformSection"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<PlatformSectionForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject PlatformSectionForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22PlatformSectionForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22PlatformSectionForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22PlatformSectionForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN20RentalVehicleForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto RentalVehicleForeign::qt_create_metaobjectdata<qt_meta_tag_ZN20RentalVehicleForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RentalVehicleForeign",
        "QML.Foreign",
        "KPublicTransport::RentalVehicle",
        "QML.Element",
        "rentalVehicle",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<RentalVehicleForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RentalVehicleForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20RentalVehicleForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20RentalVehicleForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20RentalVehicleForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN20RentalVehicleDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<RentalVehicleDerived, qt_meta_tag_ZN20RentalVehicleDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject RentalVehicleDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::RentalVehicle>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20RentalVehicleDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20RentalVehicleDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20RentalVehicleDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN27RentalVehicleNetworkForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto RentalVehicleNetworkForeign::qt_create_metaobjectdata<qt_meta_tag_ZN27RentalVehicleNetworkForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RentalVehicleNetworkForeign",
        "QML.Foreign",
        "KPublicTransport::RentalVehicleNetwork",
        "QML.Element",
        "rentalVehicleNetwork"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<RentalVehicleNetworkForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RentalVehicleNetworkForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27RentalVehicleNetworkForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27RentalVehicleNetworkForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27RentalVehicleNetworkForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN27RentalVehicleStationForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto RentalVehicleStationForeign::qt_create_metaobjectdata<qt_meta_tag_ZN27RentalVehicleStationForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RentalVehicleStationForeign",
        "QML.Foreign",
        "KPublicTransport::RentalVehicleStation",
        "QML.Element",
        "rentalVehicleStation"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<RentalVehicleStationForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RentalVehicleStationForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27RentalVehicleStationForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27RentalVehicleStationForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27RentalVehicleStationForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN24RentalVehicleTypeForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto RentalVehicleTypeForeign::qt_create_metaobjectdata<qt_meta_tag_ZN24RentalVehicleTypeForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RentalVehicleTypeForeign",
        "QML.Foreign",
        "KPublicTransport::RentalVehicleType",
        "QML.Element",
        "rentalVehicleType"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<RentalVehicleTypeForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RentalVehicleTypeForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24RentalVehicleTypeForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24RentalVehicleTypeForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24RentalVehicleTypeForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN24RentalVehicleTypeDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<RentalVehicleTypeDerived, qt_meta_tag_ZN24RentalVehicleTypeDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject RentalVehicleTypeDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::RentalVehicleType>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24RentalVehicleTypeDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24RentalVehicleTypeDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24RentalVehicleTypeDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN12ReplyForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto ReplyForeign::qt_create_metaobjectdata<qt_meta_tag_ZN12ReplyForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ReplyForeign",
        "QML.Foreign",
        "KPublicTransport::Reply",
        "QML.Element",
        "Reply",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        ""
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<ReplyForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject ReplyForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12ReplyForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12ReplyForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12ReplyForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN12RouteForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto RouteForeign::qt_create_metaobjectdata<qt_meta_tag_ZN12RouteForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RouteForeign",
        "QML.Foreign",
        "KPublicTransport::Route",
        "QML.Element",
        "route",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<RouteForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RouteForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12RouteForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12RouteForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12RouteForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22StopInformationForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto StopInformationForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22StopInformationForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "StopInformationForeign",
        "QML.Foreign",
        "KPublicTransport::StopInformation",
        "QML.Element",
        "stopInformation"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<StopInformationForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject StopInformationForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22StopInformationForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22StopInformationForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22StopInformationForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN15StopoverForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto StopoverForeign::qt_create_metaobjectdata<qt_meta_tag_ZN15StopoverForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "StopoverForeign",
        "QML.Foreign",
        "KPublicTransport::Stopover",
        "QML.Element",
        "stopover",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<StopoverForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject StopoverForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15StopoverForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15StopoverForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15StopoverForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22StopoverRequestForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto StopoverRequestForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22StopoverRequestForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "StopoverRequestForeign",
        "QML.Foreign",
        "KPublicTransport::StopoverRequest",
        "QML.Element",
        "stopoverRequest",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<StopoverRequestForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject StopoverRequestForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22StopoverRequestForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22StopoverRequestForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22StopoverRequestForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22StopoverRequestDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<StopoverRequestDerived, qt_meta_tag_ZN22StopoverRequestDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject StopoverRequestDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::StopoverRequest>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22StopoverRequestDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22StopoverRequestDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22StopoverRequestDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN25StopoverQueryModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto StopoverQueryModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN25StopoverQueryModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "StopoverQueryModelForeign",
        "QML.Foreign",
        "KPublicTransport::StopoverQueryModel",
        "QML.Element",
        "StopoverQueryModel"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<StopoverQueryModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject StopoverQueryModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25StopoverQueryModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25StopoverQueryModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN25StopoverQueryModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18TripRequestForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto TripRequestForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18TripRequestForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "TripRequestForeign",
        "QML.Foreign",
        "KPublicTransport::TripRequest",
        "QML.Element",
        "tripRequest",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<TripRequestForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject TripRequestForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18TripRequestForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18TripRequestForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18TripRequestForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN14VehicleForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto VehicleForeign::qt_create_metaobjectdata<qt_meta_tag_ZN14VehicleForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "VehicleForeign",
        "QML.Foreign",
        "KPublicTransport::Vehicle",
        "QML.Element",
        "vehicle",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "only provided from C++ API"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<VehicleForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject VehicleForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14VehicleForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14VehicleForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14VehicleForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN14VehicleDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<VehicleDerived, qt_meta_tag_ZN14VehicleDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject VehicleDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::Vehicle>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14VehicleDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14VehicleDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14VehicleDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN27VehicleLayoutRequestForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto VehicleLayoutRequestForeign::qt_create_metaobjectdata<qt_meta_tag_ZN27VehicleLayoutRequestForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "VehicleLayoutRequestForeign",
        "QML.Foreign",
        "KPublicTransport::VehicleLayoutRequest",
        "QML.Element",
        "vehicleLayoutRequest",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<VehicleLayoutRequestForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject VehicleLayoutRequestForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27VehicleLayoutRequestForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27VehicleLayoutRequestForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27VehicleLayoutRequestForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN27VehicleLayoutRequestDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<VehicleLayoutRequestDerived, qt_meta_tag_ZN27VehicleLayoutRequestDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject VehicleLayoutRequestDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::VehicleLayoutRequest>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27VehicleLayoutRequestDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27VehicleLayoutRequestDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27VehicleLayoutRequestDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN30VehicleLayoutQueryModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto VehicleLayoutQueryModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN30VehicleLayoutQueryModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "VehicleLayoutQueryModelForeign",
        "QML.Foreign",
        "KPublicTransport::VehicleLayoutQueryModel",
        "QML.Element",
        "VehicleLayoutQueryModel"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<VehicleLayoutQueryModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject VehicleLayoutQueryModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN30VehicleLayoutQueryModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN30VehicleLayoutQueryModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN30VehicleLayoutQueryModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21VehicleSectionForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto VehicleSectionForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21VehicleSectionForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "VehicleSectionForeign",
        "QML.Foreign",
        "KPublicTransport::VehicleSection",
        "QML.Element",
        "vehicleSection",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "only provided from C++ API"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<VehicleSectionForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject VehicleSectionForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21VehicleSectionForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21VehicleSectionForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21VehicleSectionForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21VehicleSectionDerivedE_t {};
} // unnamed namespace

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

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<VehicleSectionDerived, qt_meta_tag_ZN21VehicleSectionDerivedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject VehicleSectionDerived::staticMetaObject = { {
    QtPrivate::MetaObjectForType<KPublicTransport::VehicleSection>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21VehicleSectionDerivedE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21VehicleSectionDerivedE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21VehicleSectionDerivedE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN25KPublicTransportQmlPluginE_t {};
} // unnamed namespace

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

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

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

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

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

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

#ifdef QT_MOC_EXPORT_PLUGIN_V2
static constexpr unsigned char qt_pluginMetaDataV2_KPublicTransportQmlPlugin[] = {
    0xbf, 
    // "IID"
    0x02,  0x78,  0x28,  'o',  'r',  'g',  '.',  'q', 
    't',  '-',  'p',  'r',  'o',  'j',  'e',  'c', 
    't',  '.',  'Q',  't',  '.',  'Q',  'Q',  'm', 
    'l',  'E',  'x',  't',  'e',  'n',  's',  'i', 
    'o',  'n',  'I',  'n',  't',  'e',  'r',  'f', 
    'a',  'c',  'e', 
    // "className"
    0x03,  0x78,  0x19,  'K',  'P',  'u',  'b',  'l', 
    'i',  'c',  'T',  'r',  'a',  'n',  's',  'p', 
    'o',  'r',  't',  'Q',  'm',  'l',  'P',  'l', 
    'u',  'g',  'i',  'n', 
    // command-line "uri"
    0x63,  'u',  'r',  'i',  0x81,  0x78,  0x18,  'o', 
    'r',  'g',  '.',  'k',  'd',  'e',  '.',  'k', 
    'p',  'u',  'b',  'l',  'i',  'c',  't',  'r', 
    'a',  'n',  's',  'p',  'o',  'r',  't', 
    0xff, 
};
QT_MOC_EXPORT_PLUGIN_V2(KPublicTransportQmlPlugin, KPublicTransportQmlPlugin, qt_pluginMetaDataV2_KPublicTransportQmlPlugin)
#else
QT_PLUGIN_METADATA_SECTION
Q_CONSTINIT static constexpr unsigned char qt_pluginMetaData_KPublicTransportQmlPlugin[] = {
    '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,  0x28,  'o',  'r',  'g',  '.',  'q', 
    't',  '-',  'p',  'r',  'o',  'j',  'e',  'c', 
    't',  '.',  'Q',  't',  '.',  'Q',  'Q',  'm', 
    'l',  'E',  'x',  't',  'e',  'n',  's',  'i', 
    'o',  'n',  'I',  'n',  't',  'e',  'r',  'f', 
    'a',  'c',  'e', 
    // "className"
    0x03,  0x78,  0x19,  'K',  'P',  'u',  'b',  'l', 
    'i',  'c',  'T',  'r',  'a',  'n',  's',  'p', 
    'o',  'r',  't',  'Q',  'm',  'l',  'P',  'l', 
    'u',  'g',  'i',  'n', 
    // command-line "uri"
    0x63,  'u',  'r',  'i',  0x81,  0x78,  0x18,  'o', 
    'r',  'g',  '.',  'k',  'd',  'e',  '.',  'k', 
    'p',  'u',  'b',  'l',  'i',  'c',  't',  'r', 
    'a',  'n',  's',  'p',  'o',  'r',  't', 
    0xff, 
};
QT_MOC_EXPORT_PLUGIN(KPublicTransportQmlPlugin, KPublicTransportQmlPlugin)
#endif  // QT_MOC_EXPORT_PLUGIN_V2

namespace {
struct qt_meta_tag_ZN26CoverageAreaDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto CoverageAreaDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN26CoverageAreaDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CoverageAreaDerivedForeign",
        "QML.Element",
        "CoverageArea",
        "QML.Foreign",
        "CoverageAreaDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN26CoverageAreaDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN26CoverageAreaDerivedForeignE =
    CoverageAreaDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN26CoverageAreaDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN26CoverageAreaDerivedForeignE =
    qt_staticMetaObjectContent_ZN26CoverageAreaDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN26CoverageAreaDerivedForeignE =
    qt_staticMetaObjectContent_ZN26CoverageAreaDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject CoverageAreaDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN26CoverageAreaDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN26CoverageAreaDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN26CoverageAreaDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17DisruptionForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto DisruptionForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17DisruptionForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DisruptionForeign",
        "QML.Element",
        "Disruption",
        "QML.Foreign",
        "KPublicTransport::Disruption",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN17DisruptionForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN17DisruptionForeignE =
    DisruptionForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17DisruptionForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN17DisruptionForeignE =
    qt_staticMetaObjectContent_ZN17DisruptionForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN17DisruptionForeignE =
    qt_staticMetaObjectContent_ZN17DisruptionForeignE.relocatingData;

Q_CONSTINIT const QMetaObject DisruptionForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN17DisruptionForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN17DisruptionForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN17DisruptionForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN23EquipmentDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto EquipmentDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23EquipmentDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "EquipmentDerivedForeign",
        "QML.Element",
        "Equipment",
        "QML.Foreign",
        "EquipmentDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN23EquipmentDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN23EquipmentDerivedForeignE =
    EquipmentDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23EquipmentDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN23EquipmentDerivedForeignE =
    qt_staticMetaObjectContent_ZN23EquipmentDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN23EquipmentDerivedForeignE =
    qt_staticMetaObjectContent_ZN23EquipmentDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject EquipmentDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN23EquipmentDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN23EquipmentDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN23EquipmentDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21FeatureDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto FeatureDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21FeatureDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "FeatureDerivedForeign",
        "QML.Element",
        "Feature",
        "QML.Foreign",
        "FeatureDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN21FeatureDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN21FeatureDerivedForeignE =
    FeatureDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21FeatureDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN21FeatureDerivedForeignE =
    qt_staticMetaObjectContent_ZN21FeatureDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN21FeatureDerivedForeignE =
    qt_staticMetaObjectContent_ZN21FeatureDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject FeatureDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN21FeatureDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN21FeatureDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN21FeatureDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN33IndividualTransportDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto IndividualTransportDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN33IndividualTransportDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "IndividualTransportDerivedForeign",
        "QML.Element",
        "IndividualTransport",
        "QML.Foreign",
        "IndividualTransportDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN33IndividualTransportDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN33IndividualTransportDerivedForeignE =
    IndividualTransportDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN33IndividualTransportDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN33IndividualTransportDerivedForeignE =
    qt_staticMetaObjectContent_ZN33IndividualTransportDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN33IndividualTransportDerivedForeignE =
    qt_staticMetaObjectContent_ZN33IndividualTransportDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject IndividualTransportDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN33IndividualTransportDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN33IndividualTransportDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN33IndividualTransportDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN28JourneyRequestDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto JourneyRequestDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28JourneyRequestDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JourneyRequestDerivedForeign",
        "QML.Element",
        "JourneyRequest",
        "QML.Foreign",
        "JourneyRequestDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN28JourneyRequestDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN28JourneyRequestDerivedForeignE =
    JourneyRequestDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28JourneyRequestDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN28JourneyRequestDerivedForeignE =
    qt_staticMetaObjectContent_ZN28JourneyRequestDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN28JourneyRequestDerivedForeignE =
    qt_staticMetaObjectContent_ZN28JourneyRequestDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject JourneyRequestDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN28JourneyRequestDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN28JourneyRequestDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN28JourneyRequestDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN28JourneySectionDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto JourneySectionDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28JourneySectionDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JourneySectionDerivedForeign",
        "QML.Element",
        "JourneySection",
        "QML.Foreign",
        "JourneySectionDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN28JourneySectionDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN28JourneySectionDerivedForeignE =
    JourneySectionDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28JourneySectionDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN28JourneySectionDerivedForeignE =
    qt_staticMetaObjectContent_ZN28JourneySectionDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN28JourneySectionDerivedForeignE =
    qt_staticMetaObjectContent_ZN28JourneySectionDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject JourneySectionDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN28JourneySectionDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN28JourneySectionDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN28JourneySectionDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18LineDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto LineDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18LineDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LineDerivedForeign",
        "QML.Element",
        "Line",
        "QML.Foreign",
        "LineDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN18LineDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN18LineDerivedForeignE =
    LineDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18LineDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN18LineDerivedForeignE =
    qt_staticMetaObjectContent_ZN18LineDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN18LineDerivedForeignE =
    qt_staticMetaObjectContent_ZN18LineDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject LineDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN18LineDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN18LineDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN18LineDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN11LoadForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto LoadForeign::qt_create_metaobjectdata<qt_meta_tag_ZN11LoadForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LoadForeign",
        "QML.Element",
        "Load",
        "QML.Foreign",
        "KPublicTransport::Load",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN11LoadForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN11LoadForeignE =
    LoadForeign::qt_create_metaobjectdata<qt_meta_tag_ZN11LoadForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN11LoadForeignE =
    qt_staticMetaObjectContent_ZN11LoadForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN11LoadForeignE =
    qt_staticMetaObjectContent_ZN11LoadForeignE.relocatingData;

Q_CONSTINIT const QMetaObject LoadForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN11LoadForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN11LoadForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN11LoadForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22LocationDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto LocationDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22LocationDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LocationDerivedForeign",
        "QML.Element",
        "Location",
        "QML.Foreign",
        "LocationDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN22LocationDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN22LocationDerivedForeignE =
    LocationDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22LocationDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN22LocationDerivedForeignE =
    qt_staticMetaObjectContent_ZN22LocationDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN22LocationDerivedForeignE =
    qt_staticMetaObjectContent_ZN22LocationDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject LocationDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN22LocationDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN22LocationDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN22LocationDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN29LocationRequestDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto LocationRequestDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN29LocationRequestDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LocationRequestDerivedForeign",
        "QML.Element",
        "LocationRequest",
        "QML.Foreign",
        "LocationRequestDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN29LocationRequestDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN29LocationRequestDerivedForeignE =
    LocationRequestDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN29LocationRequestDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN29LocationRequestDerivedForeignE =
    qt_staticMetaObjectContent_ZN29LocationRequestDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN29LocationRequestDerivedForeignE =
    qt_staticMetaObjectContent_ZN29LocationRequestDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject LocationRequestDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN29LocationRequestDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN29LocationRequestDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN29LocationRequestDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN25PathSectionDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto PathSectionDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN25PathSectionDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PathSectionDerivedForeign",
        "QML.Element",
        "PathSection",
        "QML.Foreign",
        "PathSectionDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN25PathSectionDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN25PathSectionDerivedForeignE =
    PathSectionDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN25PathSectionDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN25PathSectionDerivedForeignE =
    qt_staticMetaObjectContent_ZN25PathSectionDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN25PathSectionDerivedForeignE =
    qt_staticMetaObjectContent_ZN25PathSectionDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject PathSectionDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN25PathSectionDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN25PathSectionDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN25PathSectionDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN20PickupDropoffForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto PickupDropoffForeign::qt_create_metaobjectdata<qt_meta_tag_ZN20PickupDropoffForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PickupDropoffForeign",
        "QML.Element",
        "PickupDropoff",
        "QML.Foreign",
        "KPublicTransport::PickupDropoff",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN20PickupDropoffForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN20PickupDropoffForeignE =
    PickupDropoffForeign::qt_create_metaobjectdata<qt_meta_tag_ZN20PickupDropoffForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN20PickupDropoffForeignE =
    qt_staticMetaObjectContent_ZN20PickupDropoffForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN20PickupDropoffForeignE =
    qt_staticMetaObjectContent_ZN20PickupDropoffForeignE.relocatingData;

Q_CONSTINIT const QMetaObject PickupDropoffForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN20PickupDropoffForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN20PickupDropoffForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN20PickupDropoffForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN27RentalVehicleDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto RentalVehicleDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN27RentalVehicleDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RentalVehicleDerivedForeign",
        "QML.Element",
        "RentalVehicle",
        "QML.Foreign",
        "RentalVehicleDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN27RentalVehicleDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN27RentalVehicleDerivedForeignE =
    RentalVehicleDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN27RentalVehicleDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN27RentalVehicleDerivedForeignE =
    qt_staticMetaObjectContent_ZN27RentalVehicleDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN27RentalVehicleDerivedForeignE =
    qt_staticMetaObjectContent_ZN27RentalVehicleDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject RentalVehicleDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN27RentalVehicleDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN27RentalVehicleDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN27RentalVehicleDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN31RentalVehicleTypeDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto RentalVehicleTypeDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN31RentalVehicleTypeDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RentalVehicleTypeDerivedForeign",
        "QML.Element",
        "RentalVehicleType",
        "QML.Foreign",
        "RentalVehicleTypeDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN31RentalVehicleTypeDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN31RentalVehicleTypeDerivedForeignE =
    RentalVehicleTypeDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN31RentalVehicleTypeDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN31RentalVehicleTypeDerivedForeignE =
    qt_staticMetaObjectContent_ZN31RentalVehicleTypeDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN31RentalVehicleTypeDerivedForeignE =
    qt_staticMetaObjectContent_ZN31RentalVehicleTypeDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject RentalVehicleTypeDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN31RentalVehicleTypeDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN31RentalVehicleTypeDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN31RentalVehicleTypeDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN29StopoverRequestDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto StopoverRequestDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN29StopoverRequestDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "StopoverRequestDerivedForeign",
        "QML.Element",
        "StopoverRequest",
        "QML.Foreign",
        "StopoverRequestDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN29StopoverRequestDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN29StopoverRequestDerivedForeignE =
    StopoverRequestDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN29StopoverRequestDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN29StopoverRequestDerivedForeignE =
    qt_staticMetaObjectContent_ZN29StopoverRequestDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN29StopoverRequestDerivedForeignE =
    qt_staticMetaObjectContent_ZN29StopoverRequestDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject StopoverRequestDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN29StopoverRequestDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN29StopoverRequestDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN29StopoverRequestDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN19UpdateResultForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto UpdateResultForeign::qt_create_metaobjectdata<qt_meta_tag_ZN19UpdateResultForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "UpdateResultForeign",
        "QML.Element",
        "UpdateResult",
        "QML.Foreign",
        "KPublicTransport::UpdateResult",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN19UpdateResultForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN19UpdateResultForeignE =
    UpdateResultForeign::qt_create_metaobjectdata<qt_meta_tag_ZN19UpdateResultForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN19UpdateResultForeignE =
    qt_staticMetaObjectContent_ZN19UpdateResultForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN19UpdateResultForeignE =
    qt_staticMetaObjectContent_ZN19UpdateResultForeignE.relocatingData;

Q_CONSTINIT const QMetaObject UpdateResultForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN19UpdateResultForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN19UpdateResultForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN19UpdateResultForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21VehicleDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto VehicleDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21VehicleDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "VehicleDerivedForeign",
        "QML.Element",
        "Vehicle",
        "QML.Foreign",
        "VehicleDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN21VehicleDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN21VehicleDerivedForeignE =
    VehicleDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21VehicleDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN21VehicleDerivedForeignE =
    qt_staticMetaObjectContent_ZN21VehicleDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN21VehicleDerivedForeignE =
    qt_staticMetaObjectContent_ZN21VehicleDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject VehicleDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN21VehicleDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN21VehicleDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN21VehicleDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN34VehicleLayoutRequestDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto VehicleLayoutRequestDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN34VehicleLayoutRequestDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "VehicleLayoutRequestDerivedForeign",
        "QML.Element",
        "VehicleLayoutRequest",
        "QML.Foreign",
        "VehicleLayoutRequestDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN34VehicleLayoutRequestDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN34VehicleLayoutRequestDerivedForeignE =
    VehicleLayoutRequestDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN34VehicleLayoutRequestDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN34VehicleLayoutRequestDerivedForeignE =
    qt_staticMetaObjectContent_ZN34VehicleLayoutRequestDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN34VehicleLayoutRequestDerivedForeignE =
    qt_staticMetaObjectContent_ZN34VehicleLayoutRequestDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject VehicleLayoutRequestDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN34VehicleLayoutRequestDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN34VehicleLayoutRequestDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN34VehicleLayoutRequestDerivedForeignE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN28VehicleSectionDerivedForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto VehicleSectionDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28VehicleSectionDerivedForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "VehicleSectionDerivedForeign",
        "QML.Element",
        "VehicleSection",
        "QML.Foreign",
        "VehicleSectionDerived",
        "QML.ForeignIsNamespace",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN28VehicleSectionDerivedForeignE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN28VehicleSectionDerivedForeignE =
    VehicleSectionDerivedForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28VehicleSectionDerivedForeignE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN28VehicleSectionDerivedForeignE =
    qt_staticMetaObjectContent_ZN28VehicleSectionDerivedForeignE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN28VehicleSectionDerivedForeignE =
    qt_staticMetaObjectContent_ZN28VehicleSectionDerivedForeignE.relocatingData;

Q_CONSTINIT const QMetaObject VehicleSectionDerivedForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN28VehicleSectionDerivedForeignE.stringdata,
    qt_staticMetaObjectStaticContent_ZN28VehicleSectionDerivedForeignE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN28VehicleSectionDerivedForeignE.metaTypes,
    nullptr
} };

QT_WARNING_POP
