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

#include "../../../../PackageKit-Qt/src/transaction.h"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'transaction.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. 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_ZN10PackageKit11TransactionE_t {};
} // unnamed namespace

template <> constexpr inline auto PackageKit::Transaction::qt_create_metaobjectdata<qt_meta_tag_ZN10PackageKit11TransactionE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PackageKit::Transaction",
        "allowCancelChanged",
        "",
        "isCallerActiveChanged",
        "downloadSizeRemainingChanged",
        "elapsedTimeChanged",
        "lastPackageChanged",
        "percentageChanged",
        "remainingTimeChanged",
        "roleChanged",
        "speedChanged",
        "statusChanged",
        "transactionFlagsChanged",
        "uidChanged",
        "senderNameChanged",
        "category",
        "parentId",
        "categoryId",
        "name",
        "summary",
        "icon",
        "distroUpgrade",
        "PackageKit::Transaction::DistroUpgrade",
        "type",
        "description",
        "errorCode",
        "PackageKit::Transaction::Error",
        "error",
        "details",
        "eulaRequired",
        "eulaID",
        "packageID",
        "vendor",
        "licenseAgreement",
        "mediaChangeRequired",
        "PackageKit::Transaction::MediaType",
        "id",
        "text",
        "itemProgress",
        "itemID",
        "PackageKit::Transaction::Status",
        "status",
        "percentage",
        "files",
        "filenames",
        "finished",
        "PackageKit::Transaction::Exit",
        "runtime",
        "package",
        "PackageKit::Transaction::Info",
        "info",
        "PackageKit::Details",
        "values",
        "updateDetail",
        "updates",
        "obsoletes",
        "vendorUrls",
        "bugzillaUrls",
        "cveUrls",
        "PackageKit::Transaction::Restart",
        "restart",
        "updateText",
        "changelog",
        "PackageKit::Transaction::UpdateState",
        "state",
        "issued",
        "updated",
        "repoDetail",
        "repoId",
        "enabled",
        "repoSignatureRequired",
        "repoName",
        "keyUrl",
        "keyUserid",
        "keyId",
        "keyFingerprint",
        "keyTimestamp",
        "PackageKit::Transaction::SigType",
        "requireRestart",
        "transaction",
        "PackageKit::Transaction*",
        "QVariantMap",
        "mediaType",
        "mediaId",
        "mediaText",
        "exitCode",
        "Package",
        "pid",
        "Packages",
        "QList<PackageKit::PkPackage>",
        "ItemProgress",
        "RepoSignatureRequired",
        "QDBusObjectPath",
        "oldTid",
        "timespec",
        "succeeded",
        "role",
        "duration",
        "data",
        "uid",
        "senderName",
        "cmdline",
        "UpdateDetail",
        "package_id",
        "vendor_urls",
        "bugzilla_urls",
        "cve_urls",
        "update_text",
        "UpdateDetails",
        "QList<PackageKit::PkDetail>",
        "dets",
        "destroy",
        "daemonQuit",
        "propertiesChanged",
        "updateProperties",
        "cancel",
        "QDBusPendingReply<>",
        "tid",
        "allowCancel",
        "isCallerActive",
        "lastPackage",
        "elapsedTime",
        "remainingTime",
        "speed",
        "downloadSizeRemaining",
        "Role",
        "Status",
        "transactionFlags",
        "TransactionFlags",
        "RoleUnknown",
        "RoleCancel",
        "RoleDependsOn",
        "RoleGetDetails",
        "RoleGetFiles",
        "RoleGetPackages",
        "RoleGetRepoList",
        "RoleRequiredBy",
        "RoleGetUpdateDetail",
        "RoleGetUpdates",
        "RoleInstallFiles",
        "RoleInstallPackages",
        "RoleInstallSignature",
        "RoleRefreshCache",
        "RoleRemovePackages",
        "RoleRepoEnable",
        "RoleRepoSetData",
        "RoleResolve",
        "RoleSearchDetails",
        "RoleSearchFile",
        "RoleSearchGroup",
        "RoleSearchName",
        "RoleUpdatePackages",
        "RoleWhatProvides",
        "RoleAcceptEula",
        "RoleDownloadPackages",
        "RoleGetDistroUpgrades",
        "RoleGetCategories",
        "RoleGetOldTransactions",
        "RoleRepairSystem",
        "RoleGetDetailsLocal",
        "RoleGetFilesLocal",
        "RoleRepoRemove",
        "RoleUpgradeSystem",
        "Error",
        "ErrorUnknown",
        "ErrorOom",
        "ErrorNoNetwork",
        "ErrorNotSupported",
        "ErrorInternalError",
        "ErrorGpgFailure",
        "ErrorPackageIdInvalid",
        "ErrorPackageNotInstalled",
        "ErrorPackageNotFound",
        "ErrorPackageAlreadyInstalled",
        "ErrorPackageDownloadFailed",
        "ErrorGroupNotFound",
        "ErrorGroupListInvalid",
        "ErrorDepResolutionFailed",
        "ErrorFilterInvalid",
        "ErrorCreateThreadFailed",
        "ErrorTransactionError",
        "ErrorTransactionCancelled",
        "ErrorNoCache",
        "ErrorRepoNotFound",
        "ErrorCannotRemoveSystemPackage",
        "ErrorProcessKill",
        "ErrorFailedInitialization",
        "ErrorFailedFinalise",
        "ErrorFailedConfigParsing",
        "ErrorCannotCancel",
        "ErrorCannotGetLock",
        "ErrorNoPackagesToUpdate",
        "ErrorCannotWriteRepoConfig",
        "ErrorLocalInstallFailed",
        "ErrorBadGpgSignature",
        "ErrorMissingGpgSignature",
        "ErrorCannotInstallSourcePackage",
        "ErrorRepoConfigurationError",
        "ErrorNoLicenseAgreement",
        "ErrorFileConflicts",
        "ErrorPackageConflicts",
        "ErrorRepoNotAvailable",
        "ErrorInvalidPackageFile",
        "ErrorPackageInstallBlocked",
        "ErrorPackageCorrupt",
        "ErrorAllPackagesAlreadyInstalled",
        "ErrorFileNotFound",
        "ErrorNoMoreMirrorsToTry",
        "ErrorNoDistroUpgradeData",
        "ErrorIncompatibleArchitecture",
        "ErrorNoSpaceOnDevice",
        "ErrorMediaChangeRequired",
        "ErrorNotAuthorized",
        "ErrorUpdateNotFound",
        "ErrorCannotInstallRepoUnsigned",
        "ErrorCannotUpdateRepoUnsigned",
        "ErrorCannotGetFilelist",
        "ErrorCannotGetRequires",
        "ErrorCannotDisableRepository",
        "ErrorRestrictedDownload",
        "ErrorPackageFailedToConfigure",
        "ErrorPackageFailedToBuild",
        "ErrorPackageFailedToInstall",
        "ErrorPackageFailedToRemove",
        "ErrorUpdateFailedDueToRunningProcess",
        "ErrorPackageDatabaseChanged",
        "ErrorProvideTypeNotSupported",
        "ErrorInstallRootInvalid",
        "ErrorCannotFetchSources",
        "ErrorCancelledPriority",
        "ErrorUnfinishedTransaction",
        "ErrorLockRequired",
        "Exit",
        "ExitUnknown",
        "ExitSuccess",
        "ExitFailed",
        "ExitCancelled",
        "ExitKeyRequired",
        "ExitEulaRequired",
        "ExitKilled",
        "ExitMediaChangeRequired",
        "ExitNeedUntrusted",
        "ExitCancelledPriority",
        "ExitRepairRequired",
        "Filter",
        "FilterUnknown",
        "FilterNone",
        "FilterInstalled",
        "FilterNotInstalled",
        "FilterDevel",
        "FilterNotDevel",
        "FilterGui",
        "FilterNotGui",
        "FilterFree",
        "FilterNotFree",
        "FilterVisible",
        "FilterNotVisible",
        "FilterSupported",
        "FilterNotSupported",
        "FilterBasename",
        "FilterNotBasename",
        "FilterNewest",
        "FilterNotNewest",
        "FilterArch",
        "FilterNotArch",
        "FilterSource",
        "FilterNotSource",
        "FilterCollections",
        "FilterNotCollections",
        "FilterApplication",
        "FilterNotApplication",
        "FilterDownloaded",
        "FilterNotDownloaded",
        "FilterLast",
        "Filters",
        "StatusUnknown",
        "StatusWait",
        "StatusSetup",
        "StatusRunning",
        "StatusQuery",
        "StatusInfo",
        "StatusRemove",
        "StatusRefreshCache",
        "StatusDownload",
        "StatusInstall",
        "StatusUpdate",
        "StatusCleanup",
        "StatusObsolete",
        "StatusDepResolve",
        "StatusSigCheck",
        "StatusTestCommit",
        "StatusCommit",
        "StatusRequest",
        "StatusFinished",
        "StatusCancel",
        "StatusDownloadRepository",
        "StatusDownloadPackagelist",
        "StatusDownloadFilelist",
        "StatusDownloadChangelog",
        "StatusDownloadGroup",
        "StatusDownloadUpdateinfo",
        "StatusRepackaging",
        "StatusLoadingCache",
        "StatusScanApplications",
        "StatusGeneratePackageList",
        "StatusWaitingForLock",
        "StatusWaitingForAuth",
        "StatusScanProcessList",
        "StatusCheckExecutableFiles",
        "StatusCheckLibraries",
        "StatusCopyFiles",
        "StatusRunHook",
        "MediaType",
        "MediaTypeUnknown",
        "MediaTypeCd",
        "MediaTypeDvd",
        "MediaTypeDisc",
        "DistroUpgrade",
        "DistroUpgradeUnknown",
        "DistroUpgradeStable",
        "DistroUpgradeUnstable",
        "UpgradeKind",
        "UpgradeKindUnknown",
        "UpgradeKindMinimal",
        "UpgradeKindDefault",
        "UpgradeKindComplete",
        "TransactionFlag",
        "TransactionFlagNone",
        "TransactionFlagOnlyTrusted",
        "TransactionFlagSimulate",
        "TransactionFlagOnlyDownload",
        "TransactionFlagAllowReinstall",
        "TransactionFlagJustReinstall",
        "TransactionFlagAllowDowngrade",
        "Restart",
        "RestartUnknown",
        "RestartNone",
        "RestartApplication",
        "RestartSession",
        "RestartSystem",
        "RestartSecuritySession",
        "RestartSecuritySystem",
        "UpdateState",
        "UpdateStateUnknown",
        "UpdateStateStable",
        "UpdateStateUnstable",
        "UpdateStateTesting",
        "Group",
        "GroupUnknown",
        "GroupAccessibility",
        "GroupAccessories",
        "GroupAdminTools",
        "GroupCommunication",
        "GroupDesktopGnome",
        "GroupDesktopKde",
        "GroupDesktopOther",
        "GroupDesktopXfce",
        "GroupEducation",
        "GroupFonts",
        "GroupGames",
        "GroupGraphics",
        "GroupInternet",
        "GroupLegacy",
        "GroupLocalization",
        "GroupMaps",
        "GroupMultimedia",
        "GroupNetwork",
        "GroupOffice",
        "GroupOther",
        "GroupPowerManagement",
        "GroupProgramming",
        "GroupPublishing",
        "GroupRepos",
        "GroupSecurity",
        "GroupServers",
        "GroupSystem",
        "GroupVirtualization",
        "GroupScience",
        "GroupDocumentation",
        "GroupElectronics",
        "GroupCollections",
        "GroupVendor",
        "GroupNewest",
        "Info",
        "InfoUnknown",
        "InfoInstalled",
        "InfoAvailable",
        "InfoLow",
        "InfoEnhancement",
        "InfoNormal",
        "InfoBugfix",
        "InfoImportant",
        "InfoSecurity",
        "InfoBlocked",
        "InfoDownloading",
        "InfoUpdating",
        "InfoInstalling",
        "InfoRemoving",
        "InfoCleanup",
        "InfoObsoleting",
        "InfoCollectionInstalled",
        "InfoCollectionAvailable",
        "InfoFinished",
        "InfoReinstalling",
        "InfoDowngrading",
        "InfoPreparing",
        "InfoDecompressing",
        "InfoUntrusted",
        "InfoTrusted",
        "InfoUnavailable",
        "InfoCritical",
        "InfoInstall",
        "InfoRemove",
        "InfoObsolete",
        "InfoDowngrade",
        "SigType",
        "SigTypeUnknown",
        "SigTypeGpg"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'allowCancelChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'isCallerActiveChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'downloadSizeRemainingChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'elapsedTimeChanged'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lastPackageChanged'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'percentageChanged'
        QtMocHelpers::SignalData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'remainingTimeChanged'
        QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'roleChanged'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'speedChanged'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'statusChanged'
        QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'transactionFlagsChanged'
        QtMocHelpers::SignalData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'uidChanged'
        QtMocHelpers::SignalData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'senderNameChanged'
        QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'category'
        QtMocHelpers::SignalData<void(const QString &, const QString &, const QString &, const QString &, const QString &)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 16 }, { QMetaType::QString, 17 }, { QMetaType::QString, 18 }, { QMetaType::QString, 19 },
            { QMetaType::QString, 20 },
        }}),
        // Signal 'distroUpgrade'
        QtMocHelpers::SignalData<void(PackageKit::Transaction::DistroUpgrade, const QString &, const QString &)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 23 }, { QMetaType::QString, 18 }, { QMetaType::QString, 24 },
        }}),
        // Signal 'errorCode'
        QtMocHelpers::SignalData<void(PackageKit::Transaction::Error, const QString &)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 26, 27 }, { QMetaType::QString, 28 },
        }}),
        // Signal 'eulaRequired'
        QtMocHelpers::SignalData<void(const QString &, const QString &, const QString &, const QString &)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 30 }, { QMetaType::QString, 31 }, { QMetaType::QString, 32 }, { QMetaType::QString, 33 },
        }}),
        // Signal 'mediaChangeRequired'
        QtMocHelpers::SignalData<void(PackageKit::Transaction::MediaType, const QString &, const QString &)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 23 }, { QMetaType::QString, 36 }, { QMetaType::QString, 37 },
        }}),
        // Signal 'itemProgress'
        QtMocHelpers::SignalData<void(const QString &, PackageKit::Transaction::Status, uint)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 }, { 0x80000000 | 40, 41 }, { QMetaType::UInt, 42 },
        }}),
        // Signal 'files'
        QtMocHelpers::SignalData<void(const QString &, const QStringList &)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 31 }, { QMetaType::QStringList, 44 },
        }}),
        // Signal 'finished'
        QtMocHelpers::SignalData<void(PackageKit::Transaction::Exit, uint)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 46, 41 }, { QMetaType::UInt, 47 },
        }}),
        // Signal 'package'
        QtMocHelpers::SignalData<void(PackageKit::Transaction::Info, const QString &, const QString &)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 49, 50 }, { QMetaType::QString, 31 }, { QMetaType::QString, 19 },
        }}),
        // Signal 'details'
        QtMocHelpers::SignalData<void(const PackageKit::Details &)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 51, 52 },
        }}),
        // Signal 'updateDetail'
        QtMocHelpers::SignalData<void(const QString &, const QStringList &, const QStringList &, const QStringList &, const QStringList &, const QStringList &, PackageKit::Transaction::Restart, const QString &, const QString &, PackageKit::Transaction::UpdateState, const QDateTime &, const QDateTime &)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 31 }, { QMetaType::QStringList, 54 }, { QMetaType::QStringList, 55 }, { QMetaType::QStringList, 56 },
            { QMetaType::QStringList, 57 }, { QMetaType::QStringList, 58 }, { 0x80000000 | 59, 60 }, { QMetaType::QString, 61 },
            { QMetaType::QString, 62 }, { 0x80000000 | 63, 64 }, { QMetaType::QDateTime, 65 }, { QMetaType::QDateTime, 66 },
        }}),
        // Signal 'repoDetail'
        QtMocHelpers::SignalData<void(const QString &, const QString &, bool)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 68 }, { QMetaType::QString, 24 }, { QMetaType::Bool, 69 },
        }}),
        // Signal 'repoSignatureRequired'
        QtMocHelpers::SignalData<void(const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, PackageKit::Transaction::SigType)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 31 }, { QMetaType::QString, 71 }, { QMetaType::QString, 72 }, { QMetaType::QString, 73 },
            { QMetaType::QString, 74 }, { QMetaType::QString, 75 }, { QMetaType::QString, 76 }, { 0x80000000 | 77, 23 },
        }}),
        // Signal 'requireRestart'
        QtMocHelpers::SignalData<void(PackageKit::Transaction::Restart, const QString &)>(78, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 59, 23 }, { QMetaType::QString, 31 },
        }}),
        // Signal 'transaction'
        QtMocHelpers::SignalData<void(PackageKit::Transaction *)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 80, 79 },
        }}),
        // Slot 'distroUpgrade'
        QtMocHelpers::SlotData<void(uint, const QString &, const QString &)>(21, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::UInt, 23 }, { QMetaType::QString, 18 }, { QMetaType::QString, 24 },
        }}),
        // Slot 'details'
        QtMocHelpers::SlotData<void(const QVariantMap &)>(28, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 81, 52 },
        }}),
        // Slot 'errorCode'
        QtMocHelpers::SlotData<void(uint, const QString &)>(25, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::UInt, 27 }, { QMetaType::QString, 28 },
        }}),
        // Slot 'mediaChangeRequired'
        QtMocHelpers::SlotData<void(uint, const QString &, const QString &)>(34, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::UInt, 82 }, { QMetaType::QString, 83 }, { QMetaType::QString, 84 },
        }}),
        // Slot 'finished'
        QtMocHelpers::SlotData<void(uint, uint)>(45, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::UInt, 85 }, { QMetaType::UInt, 47 },
        }}),
        // Slot 'Package'
        QtMocHelpers::SlotData<void(uint, const QString &, const QString &)>(86, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::UInt, 50 }, { QMetaType::QString, 87 }, { QMetaType::QString, 19 },
        }}),
        // Slot 'Packages'
        QtMocHelpers::SlotData<void(QList<PackageKit::PkPackage>)>(88, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 89, 2 },
        }}),
        // Slot 'ItemProgress'
        QtMocHelpers::SlotData<void(const QString &, uint, uint)>(90, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 39 }, { QMetaType::UInt, 41 }, { QMetaType::UInt, 42 },
        }}),
        // Slot 'RepoSignatureRequired'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, uint)>(91, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 87 }, { QMetaType::QString, 71 }, { QMetaType::QString, 72 }, { QMetaType::QString, 73 },
            { QMetaType::QString, 74 }, { QMetaType::QString, 75 }, { QMetaType::QString, 76 }, { QMetaType::UInt, 23 },
        }}),
        // Slot 'requireRestart'
        QtMocHelpers::SlotData<void(uint, const QString &)>(78, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::UInt, 23 }, { QMetaType::QString, 87 },
        }}),
        // Slot 'transaction'
        QtMocHelpers::SlotData<void(const QDBusObjectPath &, const QString &, bool, uint, uint, const QString &, uint, const QString &, const QString &)>(79, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 92, 93 }, { QMetaType::QString, 94 }, { QMetaType::Bool, 95 }, { QMetaType::UInt, 96 },
            { QMetaType::UInt, 97 }, { QMetaType::QString, 98 }, { QMetaType::UInt, 99 }, { QMetaType::QString, 100 },
            { QMetaType::QString, 101 },
        }}),
        // Slot 'UpdateDetail'
        QtMocHelpers::SlotData<void(const QString &, const QStringList &, const QStringList &, const QStringList &, const QStringList &, const QStringList &, uint, const QString &, const QString &, uint, const QString &, const QString &)>(102, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 103 }, { QMetaType::QStringList, 54 }, { QMetaType::QStringList, 55 }, { QMetaType::QStringList, 104 },
            { QMetaType::QStringList, 105 }, { QMetaType::QStringList, 106 }, { QMetaType::UInt, 60 }, { QMetaType::QString, 107 },
            { QMetaType::QString, 62 }, { QMetaType::UInt, 64 }, { QMetaType::QString, 65 }, { QMetaType::QString, 66 },
        }}),
        // Slot 'UpdateDetails'
        QtMocHelpers::SlotData<void(const QList<PackageKit::PkDetail> &)>(108, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 109, 110 },
        }}),
        // Slot 'destroy'
        QtMocHelpers::SlotData<void()>(111, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'daemonQuit'
        QtMocHelpers::SlotData<void()>(112, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'propertiesChanged'
        QtMocHelpers::SlotData<void(QString, QVariantMap, QStringList)>(113, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 81, 2 }, { QMetaType::QStringList, 2 },
        }}),
        // Slot 'updateProperties'
        QtMocHelpers::SlotData<void(QVariantMap)>(114, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 81, 2 },
        }}),
        // Method 'cancel'
        QtMocHelpers::MethodData<QDBusPendingReply<>()>(115, 2, QMC::AccessPublic, 0x80000000 | 116),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'tid'
        QtMocHelpers::PropertyData<QDBusObjectPath>(117, 0x80000000 | 92, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'allowCancel'
        QtMocHelpers::PropertyData<bool>(118, QMetaType::Bool, QMC::DefaultPropertyFlags, 0),
        // property 'isCallerActive'
        QtMocHelpers::PropertyData<bool>(119, QMetaType::Bool, QMC::DefaultPropertyFlags, 1),
        // property 'lastPackage'
        QtMocHelpers::PropertyData<QString>(120, QMetaType::QString, QMC::DefaultPropertyFlags, 4),
        // property 'percentage'
        QtMocHelpers::PropertyData<uint>(42, QMetaType::UInt, QMC::DefaultPropertyFlags, 5),
        // property 'elapsedTime'
        QtMocHelpers::PropertyData<uint>(121, QMetaType::UInt, QMC::DefaultPropertyFlags, 3),
        // property 'remainingTime'
        QtMocHelpers::PropertyData<uint>(122, QMetaType::UInt, QMC::DefaultPropertyFlags, 6),
        // property 'speed'
        QtMocHelpers::PropertyData<uint>(123, QMetaType::UInt, QMC::DefaultPropertyFlags, 8),
        // property 'downloadSizeRemaining'
        QtMocHelpers::PropertyData<qulonglong>(124, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 2),
        // property 'role'
        QtMocHelpers::PropertyData<enum Role>(96, 0x80000000 | 125, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 7),
        // property 'status'
        QtMocHelpers::PropertyData<enum Status>(41, 0x80000000 | 126, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 9),
        // property 'transactionFlags'
        QtMocHelpers::PropertyData<TransactionFlags>(127, 0x80000000 | 128, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 10),
        // property 'timespec'
        QtMocHelpers::PropertyData<QDateTime>(94, QMetaType::QDateTime, QMC::DefaultPropertyFlags),
        // property 'succeeded'
        QtMocHelpers::PropertyData<bool>(95, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'duration'
        QtMocHelpers::PropertyData<uint>(97, QMetaType::UInt, QMC::DefaultPropertyFlags),
        // property 'data'
        QtMocHelpers::PropertyData<QString>(98, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'uid'
        QtMocHelpers::PropertyData<uint>(99, QMetaType::UInt, QMC::DefaultPropertyFlags, 11),
        // property 'senderName'
        QtMocHelpers::PropertyData<QString>(100, QMetaType::QString, QMC::DefaultPropertyFlags, 12),
        // property 'cmdline'
        QtMocHelpers::PropertyData<QString>(101, QMetaType::QString, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Role'
        QtMocHelpers::EnumData<enum Role>(125, 125, QMC::EnumFlags{}).add({
            {  129, Role::RoleUnknown },
            {  130, Role::RoleCancel },
            {  131, Role::RoleDependsOn },
            {  132, Role::RoleGetDetails },
            {  133, Role::RoleGetFiles },
            {  134, Role::RoleGetPackages },
            {  135, Role::RoleGetRepoList },
            {  136, Role::RoleRequiredBy },
            {  137, Role::RoleGetUpdateDetail },
            {  138, Role::RoleGetUpdates },
            {  139, Role::RoleInstallFiles },
            {  140, Role::RoleInstallPackages },
            {  141, Role::RoleInstallSignature },
            {  142, Role::RoleRefreshCache },
            {  143, Role::RoleRemovePackages },
            {  144, Role::RoleRepoEnable },
            {  145, Role::RoleRepoSetData },
            {  146, Role::RoleResolve },
            {  147, Role::RoleSearchDetails },
            {  148, Role::RoleSearchFile },
            {  149, Role::RoleSearchGroup },
            {  150, Role::RoleSearchName },
            {  151, Role::RoleUpdatePackages },
            {  152, Role::RoleWhatProvides },
            {  153, Role::RoleAcceptEula },
            {  154, Role::RoleDownloadPackages },
            {  155, Role::RoleGetDistroUpgrades },
            {  156, Role::RoleGetCategories },
            {  157, Role::RoleGetOldTransactions },
            {  158, Role::RoleRepairSystem },
            {  159, Role::RoleGetDetailsLocal },
            {  160, Role::RoleGetFilesLocal },
            {  161, Role::RoleRepoRemove },
            {  162, Role::RoleUpgradeSystem },
        }),
        // enum 'Error'
        QtMocHelpers::EnumData<enum Error>(163, 163, QMC::EnumFlags{}).add({
            {  164, Error::ErrorUnknown },
            {  165, Error::ErrorOom },
            {  166, Error::ErrorNoNetwork },
            {  167, Error::ErrorNotSupported },
            {  168, Error::ErrorInternalError },
            {  169, Error::ErrorGpgFailure },
            {  170, Error::ErrorPackageIdInvalid },
            {  171, Error::ErrorPackageNotInstalled },
            {  172, Error::ErrorPackageNotFound },
            {  173, Error::ErrorPackageAlreadyInstalled },
            {  174, Error::ErrorPackageDownloadFailed },
            {  175, Error::ErrorGroupNotFound },
            {  176, Error::ErrorGroupListInvalid },
            {  177, Error::ErrorDepResolutionFailed },
            {  178, Error::ErrorFilterInvalid },
            {  179, Error::ErrorCreateThreadFailed },
            {  180, Error::ErrorTransactionError },
            {  181, Error::ErrorTransactionCancelled },
            {  182, Error::ErrorNoCache },
            {  183, Error::ErrorRepoNotFound },
            {  184, Error::ErrorCannotRemoveSystemPackage },
            {  185, Error::ErrorProcessKill },
            {  186, Error::ErrorFailedInitialization },
            {  187, Error::ErrorFailedFinalise },
            {  188, Error::ErrorFailedConfigParsing },
            {  189, Error::ErrorCannotCancel },
            {  190, Error::ErrorCannotGetLock },
            {  191, Error::ErrorNoPackagesToUpdate },
            {  192, Error::ErrorCannotWriteRepoConfig },
            {  193, Error::ErrorLocalInstallFailed },
            {  194, Error::ErrorBadGpgSignature },
            {  195, Error::ErrorMissingGpgSignature },
            {  196, Error::ErrorCannotInstallSourcePackage },
            {  197, Error::ErrorRepoConfigurationError },
            {  198, Error::ErrorNoLicenseAgreement },
            {  199, Error::ErrorFileConflicts },
            {  200, Error::ErrorPackageConflicts },
            {  201, Error::ErrorRepoNotAvailable },
            {  202, Error::ErrorInvalidPackageFile },
            {  203, Error::ErrorPackageInstallBlocked },
            {  204, Error::ErrorPackageCorrupt },
            {  205, Error::ErrorAllPackagesAlreadyInstalled },
            {  206, Error::ErrorFileNotFound },
            {  207, Error::ErrorNoMoreMirrorsToTry },
            {  208, Error::ErrorNoDistroUpgradeData },
            {  209, Error::ErrorIncompatibleArchitecture },
            {  210, Error::ErrorNoSpaceOnDevice },
            {  211, Error::ErrorMediaChangeRequired },
            {  212, Error::ErrorNotAuthorized },
            {  213, Error::ErrorUpdateNotFound },
            {  214, Error::ErrorCannotInstallRepoUnsigned },
            {  215, Error::ErrorCannotUpdateRepoUnsigned },
            {  216, Error::ErrorCannotGetFilelist },
            {  217, Error::ErrorCannotGetRequires },
            {  218, Error::ErrorCannotDisableRepository },
            {  219, Error::ErrorRestrictedDownload },
            {  220, Error::ErrorPackageFailedToConfigure },
            {  221, Error::ErrorPackageFailedToBuild },
            {  222, Error::ErrorPackageFailedToInstall },
            {  223, Error::ErrorPackageFailedToRemove },
            {  224, Error::ErrorUpdateFailedDueToRunningProcess },
            {  225, Error::ErrorPackageDatabaseChanged },
            {  226, Error::ErrorProvideTypeNotSupported },
            {  227, Error::ErrorInstallRootInvalid },
            {  228, Error::ErrorCannotFetchSources },
            {  229, Error::ErrorCancelledPriority },
            {  230, Error::ErrorUnfinishedTransaction },
            {  231, Error::ErrorLockRequired },
        }),
        // enum 'Exit'
        QtMocHelpers::EnumData<enum Exit>(232, 232, QMC::EnumFlags{}).add({
            {  233, Exit::ExitUnknown },
            {  234, Exit::ExitSuccess },
            {  235, Exit::ExitFailed },
            {  236, Exit::ExitCancelled },
            {  237, Exit::ExitKeyRequired },
            {  238, Exit::ExitEulaRequired },
            {  239, Exit::ExitKilled },
            {  240, Exit::ExitMediaChangeRequired },
            {  241, Exit::ExitNeedUntrusted },
            {  242, Exit::ExitCancelledPriority },
            {  243, Exit::ExitRepairRequired },
        }),
        // enum 'Filter'
        QtMocHelpers::EnumData<enum Filter>(244, 244, QMC::EnumFlags{}).add({
            {  245, Filter::FilterUnknown },
            {  246, Filter::FilterNone },
            {  247, Filter::FilterInstalled },
            {  248, Filter::FilterNotInstalled },
            {  249, Filter::FilterDevel },
            {  250, Filter::FilterNotDevel },
            {  251, Filter::FilterGui },
            {  252, Filter::FilterNotGui },
            {  253, Filter::FilterFree },
            {  254, Filter::FilterNotFree },
            {  255, Filter::FilterVisible },
            {  256, Filter::FilterNotVisible },
            {  257, Filter::FilterSupported },
            {  258, Filter::FilterNotSupported },
            {  259, Filter::FilterBasename },
            {  260, Filter::FilterNotBasename },
            {  261, Filter::FilterNewest },
            {  262, Filter::FilterNotNewest },
            {  263, Filter::FilterArch },
            {  264, Filter::FilterNotArch },
            {  265, Filter::FilterSource },
            {  266, Filter::FilterNotSource },
            {  267, Filter::FilterCollections },
            {  268, Filter::FilterNotCollections },
            {  269, Filter::FilterApplication },
            {  270, Filter::FilterNotApplication },
            {  271, Filter::FilterDownloaded },
            {  272, Filter::FilterNotDownloaded },
            {  273, Filter::FilterLast },
        }),
        // flag 'Filters'
        QtMocHelpers::EnumData<Filters>(274, 244, QMC::EnumIsFlag).add({
            {  245, Filter::FilterUnknown },
            {  246, Filter::FilterNone },
            {  247, Filter::FilterInstalled },
            {  248, Filter::FilterNotInstalled },
            {  249, Filter::FilterDevel },
            {  250, Filter::FilterNotDevel },
            {  251, Filter::FilterGui },
            {  252, Filter::FilterNotGui },
            {  253, Filter::FilterFree },
            {  254, Filter::FilterNotFree },
            {  255, Filter::FilterVisible },
            {  256, Filter::FilterNotVisible },
            {  257, Filter::FilterSupported },
            {  258, Filter::FilterNotSupported },
            {  259, Filter::FilterBasename },
            {  260, Filter::FilterNotBasename },
            {  261, Filter::FilterNewest },
            {  262, Filter::FilterNotNewest },
            {  263, Filter::FilterArch },
            {  264, Filter::FilterNotArch },
            {  265, Filter::FilterSource },
            {  266, Filter::FilterNotSource },
            {  267, Filter::FilterCollections },
            {  268, Filter::FilterNotCollections },
            {  269, Filter::FilterApplication },
            {  270, Filter::FilterNotApplication },
            {  271, Filter::FilterDownloaded },
            {  272, Filter::FilterNotDownloaded },
            {  273, Filter::FilterLast },
        }),
        // enum 'Status'
        QtMocHelpers::EnumData<enum Status>(126, 126, QMC::EnumFlags{}).add({
            {  275, Status::StatusUnknown },
            {  276, Status::StatusWait },
            {  277, Status::StatusSetup },
            {  278, Status::StatusRunning },
            {  279, Status::StatusQuery },
            {  280, Status::StatusInfo },
            {  281, Status::StatusRemove },
            {  282, Status::StatusRefreshCache },
            {  283, Status::StatusDownload },
            {  284, Status::StatusInstall },
            {  285, Status::StatusUpdate },
            {  286, Status::StatusCleanup },
            {  287, Status::StatusObsolete },
            {  288, Status::StatusDepResolve },
            {  289, Status::StatusSigCheck },
            {  290, Status::StatusTestCommit },
            {  291, Status::StatusCommit },
            {  292, Status::StatusRequest },
            {  293, Status::StatusFinished },
            {  294, Status::StatusCancel },
            {  295, Status::StatusDownloadRepository },
            {  296, Status::StatusDownloadPackagelist },
            {  297, Status::StatusDownloadFilelist },
            {  298, Status::StatusDownloadChangelog },
            {  299, Status::StatusDownloadGroup },
            {  300, Status::StatusDownloadUpdateinfo },
            {  301, Status::StatusRepackaging },
            {  302, Status::StatusLoadingCache },
            {  303, Status::StatusScanApplications },
            {  304, Status::StatusGeneratePackageList },
            {  305, Status::StatusWaitingForLock },
            {  306, Status::StatusWaitingForAuth },
            {  307, Status::StatusScanProcessList },
            {  308, Status::StatusCheckExecutableFiles },
            {  309, Status::StatusCheckLibraries },
            {  310, Status::StatusCopyFiles },
            {  311, Status::StatusRunHook },
        }),
        // enum 'MediaType'
        QtMocHelpers::EnumData<enum MediaType>(312, 312, QMC::EnumFlags{}).add({
            {  313, MediaType::MediaTypeUnknown },
            {  314, MediaType::MediaTypeCd },
            {  315, MediaType::MediaTypeDvd },
            {  316, MediaType::MediaTypeDisc },
        }),
        // enum 'DistroUpgrade'
        QtMocHelpers::EnumData<enum DistroUpgrade>(317, 317, QMC::EnumFlags{}).add({
            {  318, DistroUpgrade::DistroUpgradeUnknown },
            {  319, DistroUpgrade::DistroUpgradeStable },
            {  320, DistroUpgrade::DistroUpgradeUnstable },
        }),
        // enum 'UpgradeKind'
        QtMocHelpers::EnumData<enum UpgradeKind>(321, 321, QMC::EnumFlags{}).add({
            {  322, UpgradeKind::UpgradeKindUnknown },
            {  323, UpgradeKind::UpgradeKindMinimal },
            {  324, UpgradeKind::UpgradeKindDefault },
            {  325, UpgradeKind::UpgradeKindComplete },
        }),
        // enum 'TransactionFlag'
        QtMocHelpers::EnumData<enum TransactionFlag>(326, 326, QMC::EnumFlags{}).add({
            {  327, TransactionFlag::TransactionFlagNone },
            {  328, TransactionFlag::TransactionFlagOnlyTrusted },
            {  329, TransactionFlag::TransactionFlagSimulate },
            {  330, TransactionFlag::TransactionFlagOnlyDownload },
            {  331, TransactionFlag::TransactionFlagAllowReinstall },
            {  332, TransactionFlag::TransactionFlagJustReinstall },
            {  333, TransactionFlag::TransactionFlagAllowDowngrade },
        }),
        // flag 'TransactionFlags'
        QtMocHelpers::EnumData<TransactionFlags>(128, 326, QMC::EnumIsFlag).add({
            {  327, TransactionFlag::TransactionFlagNone },
            {  328, TransactionFlag::TransactionFlagOnlyTrusted },
            {  329, TransactionFlag::TransactionFlagSimulate },
            {  330, TransactionFlag::TransactionFlagOnlyDownload },
            {  331, TransactionFlag::TransactionFlagAllowReinstall },
            {  332, TransactionFlag::TransactionFlagJustReinstall },
            {  333, TransactionFlag::TransactionFlagAllowDowngrade },
        }),
        // enum 'Restart'
        QtMocHelpers::EnumData<enum Restart>(334, 334, QMC::EnumFlags{}).add({
            {  335, Restart::RestartUnknown },
            {  336, Restart::RestartNone },
            {  337, Restart::RestartApplication },
            {  338, Restart::RestartSession },
            {  339, Restart::RestartSystem },
            {  340, Restart::RestartSecuritySession },
            {  341, Restart::RestartSecuritySystem },
        }),
        // enum 'UpdateState'
        QtMocHelpers::EnumData<enum UpdateState>(342, 342, QMC::EnumFlags{}).add({
            {  343, UpdateState::UpdateStateUnknown },
            {  344, UpdateState::UpdateStateStable },
            {  345, UpdateState::UpdateStateUnstable },
            {  346, UpdateState::UpdateStateTesting },
        }),
        // enum 'Group'
        QtMocHelpers::EnumData<enum Group>(347, 347, QMC::EnumFlags{}).add({
            {  348, Group::GroupUnknown },
            {  349, Group::GroupAccessibility },
            {  350, Group::GroupAccessories },
            {  351, Group::GroupAdminTools },
            {  352, Group::GroupCommunication },
            {  353, Group::GroupDesktopGnome },
            {  354, Group::GroupDesktopKde },
            {  355, Group::GroupDesktopOther },
            {  356, Group::GroupDesktopXfce },
            {  357, Group::GroupEducation },
            {  358, Group::GroupFonts },
            {  359, Group::GroupGames },
            {  360, Group::GroupGraphics },
            {  361, Group::GroupInternet },
            {  362, Group::GroupLegacy },
            {  363, Group::GroupLocalization },
            {  364, Group::GroupMaps },
            {  365, Group::GroupMultimedia },
            {  366, Group::GroupNetwork },
            {  367, Group::GroupOffice },
            {  368, Group::GroupOther },
            {  369, Group::GroupPowerManagement },
            {  370, Group::GroupProgramming },
            {  371, Group::GroupPublishing },
            {  372, Group::GroupRepos },
            {  373, Group::GroupSecurity },
            {  374, Group::GroupServers },
            {  375, Group::GroupSystem },
            {  376, Group::GroupVirtualization },
            {  377, Group::GroupScience },
            {  378, Group::GroupDocumentation },
            {  379, Group::GroupElectronics },
            {  380, Group::GroupCollections },
            {  381, Group::GroupVendor },
            {  382, Group::GroupNewest },
        }),
        // enum 'Info'
        QtMocHelpers::EnumData<enum Info>(383, 383, QMC::EnumFlags{}).add({
            {  384, Info::InfoUnknown },
            {  385, Info::InfoInstalled },
            {  386, Info::InfoAvailable },
            {  387, Info::InfoLow },
            {  388, Info::InfoEnhancement },
            {  389, Info::InfoNormal },
            {  390, Info::InfoBugfix },
            {  391, Info::InfoImportant },
            {  392, Info::InfoSecurity },
            {  393, Info::InfoBlocked },
            {  394, Info::InfoDownloading },
            {  395, Info::InfoUpdating },
            {  396, Info::InfoInstalling },
            {  397, Info::InfoRemoving },
            {  398, Info::InfoCleanup },
            {  399, Info::InfoObsoleting },
            {  400, Info::InfoCollectionInstalled },
            {  401, Info::InfoCollectionAvailable },
            {  402, Info::InfoFinished },
            {  403, Info::InfoReinstalling },
            {  404, Info::InfoDowngrading },
            {  405, Info::InfoPreparing },
            {  406, Info::InfoDecompressing },
            {  407, Info::InfoUntrusted },
            {  408, Info::InfoTrusted },
            {  409, Info::InfoUnavailable },
            {  410, Info::InfoCritical },
            {  411, Info::InfoInstall },
            {  412, Info::InfoRemove },
            {  413, Info::InfoObsolete },
            {  414, Info::InfoDowngrade },
        }),
        // enum 'SigType'
        QtMocHelpers::EnumData<enum SigType>(415, 415, QMC::EnumFlags{}).add({
            {  416, SigType::SigTypeUnknown },
            {  417, SigType::SigTypeGpg },
        }),
    };
    return QtMocHelpers::metaObjectData<Transaction, qt_meta_tag_ZN10PackageKit11TransactionE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject PackageKit::Transaction::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10PackageKit11TransactionE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10PackageKit11TransactionE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN10PackageKit11TransactionE_t>.metaTypes,
    nullptr
} };

void PackageKit::Transaction::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Transaction *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->allowCancelChanged(); break;
        case 1: _t->isCallerActiveChanged(); break;
        case 2: _t->downloadSizeRemainingChanged(); break;
        case 3: _t->elapsedTimeChanged(); break;
        case 4: _t->lastPackageChanged(); break;
        case 5: _t->percentageChanged(); break;
        case 6: _t->remainingTimeChanged(); break;
        case 7: _t->roleChanged(); break;
        case 8: _t->speedChanged(); break;
        case 9: _t->statusChanged(); break;
        case 10: _t->transactionFlagsChanged(); break;
        case 11: _t->uidChanged(); break;
        case 12: _t->senderNameChanged(); break;
        case 13: _t->category((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[5]))); break;
        case 14: _t->distroUpgrade((*reinterpret_cast<std::add_pointer_t<PackageKit::Transaction::DistroUpgrade>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 15: _t->errorCode((*reinterpret_cast<std::add_pointer_t<PackageKit::Transaction::Error>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 16: _t->eulaRequired((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4]))); break;
        case 17: _t->mediaChangeRequired((*reinterpret_cast<std::add_pointer_t<PackageKit::Transaction::MediaType>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 18: _t->itemProgress((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<PackageKit::Transaction::Status>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[3]))); break;
        case 19: _t->files((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2]))); break;
        case 20: _t->finished((*reinterpret_cast<std::add_pointer_t<PackageKit::Transaction::Exit>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[2]))); break;
        case 21: _t->package((*reinterpret_cast<std::add_pointer_t<PackageKit::Transaction::Info>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 22: _t->details((*reinterpret_cast<std::add_pointer_t<PackageKit::Details>>(_a[1]))); break;
        case 23: _t->updateDetail((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<PackageKit::Transaction::Restart>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[8])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[9])),(*reinterpret_cast<std::add_pointer_t<PackageKit::Transaction::UpdateState>>(_a[10])),(*reinterpret_cast<std::add_pointer_t<QDateTime>>(_a[11])),(*reinterpret_cast<std::add_pointer_t<QDateTime>>(_a[12]))); break;
        case 24: _t->repoDetail((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 25: _t->repoSignatureRequired((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<PackageKit::Transaction::SigType>>(_a[8]))); break;
        case 26: _t->requireRestart((*reinterpret_cast<std::add_pointer_t<PackageKit::Transaction::Restart>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 27: _t->transaction((*reinterpret_cast<std::add_pointer_t<PackageKit::Transaction*>>(_a[1]))); break;
        case 28: _t->d_func()->distroUpgrade((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 29: _t->d_func()->details((*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[1]))); break;
        case 30: _t->d_func()->errorCode((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 31: _t->d_func()->mediaChangeRequired((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 32: _t->d_func()->finished((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[2]))); break;
        case 33: _t->d_func()->Package((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 34: _t->d_func()->Packages((*reinterpret_cast<std::add_pointer_t<QList<PackageKit::PkPackage>>>(_a[1]))); break;
        case 35: _t->d_func()->ItemProgress((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[3]))); break;
        case 36: _t->d_func()->RepoSignatureRequired((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[8]))); break;
        case 37: _t->d_func()->requireRestart((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 38: _t->d_func()->transaction((*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[8])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[9]))); break;
        case 39: _t->d_func()->UpdateDetail((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[8])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[9])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[10])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[11])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[12]))); break;
        case 40: _t->d_func()->UpdateDetails((*reinterpret_cast<std::add_pointer_t<QList<PackageKit::PkDetail>>>(_a[1]))); break;
        case 41: _t->d_func()->destroy(); break;
        case 42: _t->d_func()->daemonQuit(); break;
        case 43: _t->d_func()->propertiesChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[3]))); break;
        case 44: _t->d_func()->updateProperties((*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[1]))); break;
        case 45: { QDBusPendingReply<> _r = _t->cancel();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 14:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PackageKit::Transaction::DistroUpgrade >(); break;
            }
            break;
        case 15:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PackageKit::Transaction::Error >(); break;
            }
            break;
        case 17:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PackageKit::Transaction::MediaType >(); break;
            }
            break;
        case 18:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PackageKit::Transaction::Status >(); break;
            }
            break;
        case 20:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PackageKit::Transaction::Exit >(); break;
            }
            break;
        case 21:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PackageKit::Transaction::Info >(); break;
            }
            break;
        case 23:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 6:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PackageKit::Transaction::Restart >(); break;
            case 9:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PackageKit::Transaction::UpdateState >(); break;
            }
            break;
        case 25:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 7:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PackageKit::Transaction::SigType >(); break;
            }
            break;
        case 26:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PackageKit::Transaction::Restart >(); break;
            }
            break;
        case 27:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PackageKit::Transaction* >(); break;
            }
            break;
        case 38:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::allowCancelChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::isCallerActiveChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::downloadSizeRemainingChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::elapsedTimeChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::lastPackageChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::percentageChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::remainingTimeChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::roleChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::speedChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::statusChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::transactionFlagsChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::uidChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)()>(_a, &Transaction::senderNameChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(const QString & , const QString & , const QString & , const QString & , const QString & )>(_a, &Transaction::category, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(PackageKit::Transaction::DistroUpgrade , const QString & , const QString & )>(_a, &Transaction::distroUpgrade, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(PackageKit::Transaction::Error , const QString & )>(_a, &Transaction::errorCode, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(const QString & , const QString & , const QString & , const QString & )>(_a, &Transaction::eulaRequired, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(PackageKit::Transaction::MediaType , const QString & , const QString & )>(_a, &Transaction::mediaChangeRequired, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(const QString & , PackageKit::Transaction::Status , uint )>(_a, &Transaction::itemProgress, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(const QString & , const QStringList & )>(_a, &Transaction::files, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(PackageKit::Transaction::Exit , uint )>(_a, &Transaction::finished, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(PackageKit::Transaction::Info , const QString & , const QString & )>(_a, &Transaction::package, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(const PackageKit::Details & )>(_a, &Transaction::details, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(const QString & , const QStringList & , const QStringList & , const QStringList & , const QStringList & , const QStringList & , PackageKit::Transaction::Restart , const QString & , const QString & , PackageKit::Transaction::UpdateState , const QDateTime & , const QDateTime & )>(_a, &Transaction::updateDetail, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(const QString & , const QString & , bool )>(_a, &Transaction::repoDetail, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(const QString & , const QString & , const QString & , const QString & , const QString & , const QString & , const QString & , PackageKit::Transaction::SigType )>(_a, &Transaction::repoSignatureRequired, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(PackageKit::Transaction::Restart , const QString & )>(_a, &Transaction::requireRestart, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (Transaction::*)(PackageKit::Transaction * )>(_a, &Transaction::transaction, 27))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusObjectPath >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QDBusObjectPath*>(_v) = _t->tid(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->allowCancel(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->isCallerActive(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->lastPackage(); break;
        case 4: *reinterpret_cast<uint*>(_v) = _t->percentage(); break;
        case 5: *reinterpret_cast<uint*>(_v) = _t->elapsedTime(); break;
        case 6: *reinterpret_cast<uint*>(_v) = _t->remainingTime(); break;
        case 7: *reinterpret_cast<uint*>(_v) = _t->speed(); break;
        case 8: *reinterpret_cast<qulonglong*>(_v) = _t->downloadSizeRemaining(); break;
        case 9: *reinterpret_cast<enum Role*>(_v) = _t->role(); break;
        case 10: *reinterpret_cast<enum Status*>(_v) = _t->status(); break;
        case 11: QtMocHelpers::assignFlags<TransactionFlags>(_v, _t->transactionFlags()); break;
        case 12: *reinterpret_cast<QDateTime*>(_v) = _t->timespec(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->succeeded(); break;
        case 14: *reinterpret_cast<uint*>(_v) = _t->duration(); break;
        case 15: *reinterpret_cast<QString*>(_v) = _t->data(); break;
        case 16: *reinterpret_cast<uint*>(_v) = _t->uid(); break;
        case 17: *reinterpret_cast<QString*>(_v) = _t->senderName(); break;
        case 18: *reinterpret_cast<QString*>(_v) = _t->cmdline(); break;
        default: break;
        }
    }
}

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

void *PackageKit::Transaction::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10PackageKit11TransactionE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int PackageKit::Transaction::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 46)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 46;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 46)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 46;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 19;
    }
    return _id;
}

// SIGNAL 0
void PackageKit::Transaction::allowCancelChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void PackageKit::Transaction::isCallerActiveChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void PackageKit::Transaction::downloadSizeRemainingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void PackageKit::Transaction::elapsedTimeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void PackageKit::Transaction::lastPackageChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void PackageKit::Transaction::percentageChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void PackageKit::Transaction::remainingTimeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void PackageKit::Transaction::roleChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void PackageKit::Transaction::speedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void PackageKit::Transaction::statusChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void PackageKit::Transaction::transactionFlagsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void PackageKit::Transaction::uidChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void PackageKit::Transaction::senderNameChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

// SIGNAL 13
void PackageKit::Transaction::category(const QString & _t1, const QString & _t2, const QString & _t3, const QString & _t4, const QString & _t5)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1, _t2, _t3, _t4, _t5);
}

// SIGNAL 14
void PackageKit::Transaction::distroUpgrade(PackageKit::Transaction::DistroUpgrade _t1, const QString & _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1, _t2, _t3);
}

// SIGNAL 15
void PackageKit::Transaction::errorCode(PackageKit::Transaction::Error _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1, _t2);
}

// SIGNAL 16
void PackageKit::Transaction::eulaRequired(const QString & _t1, const QString & _t2, const QString & _t3, const QString & _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 17
void PackageKit::Transaction::mediaChangeRequired(PackageKit::Transaction::MediaType _t1, const QString & _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1, _t2, _t3);
}

// SIGNAL 18
void PackageKit::Transaction::itemProgress(const QString & _t1, PackageKit::Transaction::Status _t2, uint _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1, _t2, _t3);
}

// SIGNAL 19
void PackageKit::Transaction::files(const QString & _t1, const QStringList & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1, _t2);
}

// SIGNAL 20
void PackageKit::Transaction::finished(PackageKit::Transaction::Exit _t1, uint _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1, _t2);
}

// SIGNAL 21
void PackageKit::Transaction::package(PackageKit::Transaction::Info _t1, const QString & _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1, _t2, _t3);
}

// SIGNAL 22
void PackageKit::Transaction::details(const PackageKit::Details & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void PackageKit::Transaction::updateDetail(const QString & _t1, const QStringList & _t2, const QStringList & _t3, const QStringList & _t4, const QStringList & _t5, const QStringList & _t6, PackageKit::Transaction::Restart _t7, const QString & _t8, const QString & _t9, PackageKit::Transaction::UpdateState _t10, const QDateTime & _t11, const QDateTime & _t12)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1, _t2, _t3, _t4, _t5, _t6, _t7, _t8, _t9, _t10, _t11, _t12);
}

// SIGNAL 24
void PackageKit::Transaction::repoDetail(const QString & _t1, const QString & _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1, _t2, _t3);
}

// SIGNAL 25
void PackageKit::Transaction::repoSignatureRequired(const QString & _t1, const QString & _t2, const QString & _t3, const QString & _t4, const QString & _t5, const QString & _t6, const QString & _t7, PackageKit::Transaction::SigType _t8)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1, _t2, _t3, _t4, _t5, _t6, _t7, _t8);
}

// SIGNAL 26
void PackageKit::Transaction::requireRestart(PackageKit::Transaction::Restart _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1, _t2);
}

// SIGNAL 27
void PackageKit::Transaction::transaction(PackageKit::Transaction * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}
QT_WARNING_POP
