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

#include "../../../udisks2-qt6/dblockpartition.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto DBlockPartition::qt_create_metaobjectdata<qt_meta_tag_ZN15DBlockPartitionE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DBlockPartition",
        "flagsChanged",
        "",
        "flags",
        "isContainedChanged",
        "isContained",
        "isContainerChanged",
        "isContainer",
        "nameChanged",
        "name",
        "numberChanged",
        "number",
        "offsetChanged",
        "offset",
        "sizeChanged",
        "size",
        "typeChanged",
        "type",
        "eTypeChanged",
        "UUIDChanged",
        "UUID",
        "guidTypeChanged",
        "deletePartition",
        "QVariantMap",
        "options",
        "resize",
        "setFlags",
        "setName",
        "setType",
        "Type",
        "table",
        "eType",
        "guidType",
        "GUIDType",
        "Empty",
        "FAT12Type",
        "XENIX_root",
        "XENIX_usr",
        "FAT16_Less_32M",
        "Extended",
        "FAT16Type",
        "HPFS_NTFS",
        "AIX",
        "AIX_bootable",
        "OS2_Boot_Manager",
        "Win95_FAT32",
        "Win95_FAT32_LBA",
        "Win95_FAT16_LBA",
        "Win95_Extended_LBA",
        "OPUS",
        "Hidden_FAT12",
        "Compaq_diagnostics",
        "Hidden_FAT16_Less_32M",
        "Hidden_FAT16",
        "Hidden_HPFS_or_NTFS",
        "AST_SmartSleep",
        "Hidden_Win95_FAT32",
        "Hidden_Win95_FAT32_LBA",
        "Hidden_Win95_FAT16_LBA",
        "NEC_DOS",
        "Plan9",
        "PartitionMagic_recovery",
        "Venix_80286",
        "PPC_PReP_Boot",
        "SFS",
        "QNX4_dot_x",
        "QNX4_dot_x_2nd_part",
        "QNX4_dot_x_3rd_part",
        "OnTrack_DM",
        "OnTrack_DM6_Aux1",
        "CP_M",
        "OnTrack_DM6_Aux3",
        "OnTrackDM6",
        "EZ_Drive",
        "Golden_Bow",
        "Priam_Edisk",
        "SpeedStor",
        "GNU_HURD_or_SysV",
        "Novell_Netware_286",
        "Novell_Netware_386",
        "DiskSecure_Multi_Boot",
        "PC_IX",
        "Old_Minix",
        "Minix_old_Linux",
        "Linux_swap",
        "Linux",
        "OS2_hidden_C_drive",
        "Linux_extended",
        "NTFS_volume_set_1",
        "NTFS_volume_set_2",
        "Linux_LVM",
        "Amoeba",
        "Amoeba_BBT",
        "BSD_OS",
        "IBM_Thinkpad_hibernation",
        "FreeBSD",
        "OpenBSD",
        "NeXTSTEP",
        "NetBSD",
        "BSDI_fs",
        "BSDI_swap",
        "Boot_Wizard_hidden",
        "DRDOS_sec_FAT12",
        "DRDOS_sec_FAT16_Less_32M",
        "DRDOS_sec_FAT16",
        "DRDOS_sec_extend",
        "Syrinx",
        "Non_FS_data",
        "Multiuser_DOS_extend",
        "CP_M_CTOS_dot_dot_dot",
        "Dell_Utility",
        "BootIt",
        "DOS_access",
        "DOS_R_O",
        "SpeedStor_1",
        "BeOS_fs",
        "EFI_GPT",
        "EFI_FAT12_16_32",
        "Linux_PA_RISC_boot",
        "SpeedStor_2",
        "SeppdStor_3",
        "DOS_secondary",
        "Linux_raid_autodetect",
        "LANstep",
        "BBT",
        "Unknow",
        "InvalidUUID",
        "GUIDTypeBegin",
        "Unused_None",
        "MBR_PS_None",
        "EFI_SP_None",
        "BIOS_BP_None",
        "iFFS_None",
        "Sony_BP_None",
        "Lenove_BP_None",
        "MSR_Win",
        "BasicData_Win",
        "LDM_Win",
        "LDM_DP_Win",
        "WRE_Win",
        "IBM_GPFS_Win",
        "SSP_Win",
        "DP_HPUX",
        "SP_HPUX",
        "LFD_Linux",
        "RAID_P_Linux",
        "RP_x86_Linux",
        "RP_x86_64_Linux",
        "RP_32bit_ARM_Linux",
        "RP_64bit_ARM_Linux",
        "SP_Linux",
        "LVM_P_Linux",
        "Home_P_Linux",
        "Srv_P_Linux",
        "Plain_DC_P_Linux",
        "LUKS_P_Linux",
        "Reserved_Linux",
        "BP_FreeBSD",
        "DP_FreeBSD",
        "SP_FreeBSD",
        "UFS_P_FreeBSD",
        "VVM_P_FreeBSD",
        "ZFS_P_FreeBSD",
        "HFS_PLUS_P_Mac",
        "UFS_Mac",
        "ZFS_Mac",
        "RAID_P_Mac",
        "RAID_P_Offline_Mac",
        "BP_Mac",
        "Label_Mac",
        "TV_RP_Mac",
        "CS_P_Mac",
        "SoftRAID_Status_Mac",
        "SoftRAID_Scratch_Mac",
        "SoftRAID_Volume_Mac",
        "SoftRAID_Cache_Mac",
        "BP_Solaris",
        "RP_Solaris",
        "SP_Solaris",
        "Backup_P_Solaris",
        "Usr_P_Solaris",
        "Var_P_Solaris",
        "Home_P_Solaris",
        "AS_Solaris",
        "Reserved_Solaris",
        "SP_NetBSD",
        "FFS_P_NetBSD",
        "LFS_P_NetBSD",
        "RAID_P_NetBSD",
        "CP_NetBSD",
        "EP_NetBSD",
        "Kernel_ChromeOS",
        "Rootfs_ChromeOS",
        "FU_ChromeOS",
        "BFS_Haiku",
        "BP_MidnightBSD",
        "DP_MidnightBSD",
        "SP_MidnightBSD",
        "UFS_P_MidnightBSD",
        "VVM_P_MidnightBSD",
        "ZFS_P_MidnightBSD",
        "Journal_Ceph",
        "DC_EJ_Ceph",
        "OSD_Ceph",
        "DC_OSD_Ceph",
        "DIC_Ceph",
        "DC_DIC_Ceph",
        "DP_OpenBSD",
        "PAFS_QNX",
        "Partition_Plan9",
        "Vmkcore_VMware",
        "VMFS_VMware",
        "Reserved_VMware",
        "Bootloader_Android",
        "Bottloader2_Android",
        "Boot_Android",
        "Recovery_Android",
        "Misc_Android",
        "Metadata_Android",
        "System_Android",
        "Cache_Android",
        "Data_Android",
        "Persistent_Android",
        "Factory_Android",
        "Fastboot_Android",
        "OEM_Android",
        "Boot_ONIE",
        "Config_ONIE",
        "Boot_PowerPC",
        "SBLC_OSes",
        "BD_P_Atari",
        "GUIDTypeEnd",
        "UnknowUUID"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'flagsChanged'
        QtMocHelpers::SignalData<void(qulonglong)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 3 },
        }}),
        // Signal 'isContainedChanged'
        QtMocHelpers::SignalData<void(bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 5 },
        }}),
        // Signal 'isContainerChanged'
        QtMocHelpers::SignalData<void(bool)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Signal 'nameChanged'
        QtMocHelpers::SignalData<void(const QString &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 9 },
        }}),
        // Signal 'numberChanged'
        QtMocHelpers::SignalData<void(uint)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 11 },
        }}),
        // Signal 'offsetChanged'
        QtMocHelpers::SignalData<void(qulonglong)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 13 },
        }}),
        // Signal 'sizeChanged'
        QtMocHelpers::SignalData<void(qulonglong)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 15 },
        }}),
        // Signal 'typeChanged'
        QtMocHelpers::SignalData<void(const QString &)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Signal 'eTypeChanged'
        QtMocHelpers::SignalData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'UUIDChanged'
        QtMocHelpers::SignalData<void(const QString &)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 20 },
        }}),
        // Signal 'guidTypeChanged'
        QtMocHelpers::SignalData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'deletePartition'
        QtMocHelpers::SlotData<void(const QVariantMap &)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 24 },
        }}),
        // Slot 'resize'
        QtMocHelpers::SlotData<void(qulonglong, const QVariantMap &)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 15 }, { 0x80000000 | 23, 24 },
        }}),
        // Slot 'setFlags'
        QtMocHelpers::SlotData<void(qulonglong, const QVariantMap &)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 3 }, { 0x80000000 | 23, 24 },
        }}),
        // Slot 'setName'
        QtMocHelpers::SlotData<void(const QString &, const QVariantMap &)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 9 }, { 0x80000000 | 23, 24 },
        }}),
        // Slot 'setType'
        QtMocHelpers::SlotData<void(const QString &, const QVariantMap &)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 }, { 0x80000000 | 23, 24 },
        }}),
        // Slot 'setType'
        QtMocHelpers::SlotData<void(enum Type, const QVariantMap &)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 29, 17 }, { 0x80000000 | 23, 24 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'flags'
        QtMocHelpers::PropertyData<qulonglong>(3, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 0),
        // property 'isContained'
        QtMocHelpers::PropertyData<bool>(5, QMetaType::Bool, QMC::DefaultPropertyFlags, 1),
        // property 'isContainer'
        QtMocHelpers::PropertyData<bool>(7, QMetaType::Bool, QMC::DefaultPropertyFlags, 2),
        // property 'name'
        QtMocHelpers::PropertyData<QString>(9, QMetaType::QString, QMC::DefaultPropertyFlags, 3),
        // property 'number'
        QtMocHelpers::PropertyData<uint>(11, QMetaType::UInt, QMC::DefaultPropertyFlags, 4),
        // property 'offset'
        QtMocHelpers::PropertyData<qulonglong>(13, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 5),
        // property 'size'
        QtMocHelpers::PropertyData<qulonglong>(15, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 6),
        // property 'table'
        QtMocHelpers::PropertyData<QString>(30, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'type'
        QtMocHelpers::PropertyData<QString>(17, QMetaType::QString, QMC::DefaultPropertyFlags, 7),
        // property 'eType'
        QtMocHelpers::PropertyData<enum Type>(31, 0x80000000 | 29, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 8),
        // property 'guidType'
        QtMocHelpers::PropertyData<enum GUIDType>(32, 0x80000000 | 33, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 10),
        // property 'UUID'
        QtMocHelpers::PropertyData<QString>(20, QMetaType::QString, QMC::DefaultPropertyFlags, 9),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Type'
        QtMocHelpers::EnumData<enum Type>(29, 29, QMC::EnumFlags{}).add({
            {   34, Type::Empty },
            {   35, Type::FAT12Type },
            {   36, Type::XENIX_root },
            {   37, Type::XENIX_usr },
            {   38, Type::FAT16_Less_32M },
            {   39, Type::Extended },
            {   40, Type::FAT16Type },
            {   41, Type::HPFS_NTFS },
            {   42, Type::AIX },
            {   43, Type::AIX_bootable },
            {   44, Type::OS2_Boot_Manager },
            {   45, Type::Win95_FAT32 },
            {   46, Type::Win95_FAT32_LBA },
            {   47, Type::Win95_FAT16_LBA },
            {   48, Type::Win95_Extended_LBA },
            {   49, Type::OPUS },
            {   50, Type::Hidden_FAT12 },
            {   51, Type::Compaq_diagnostics },
            {   52, Type::Hidden_FAT16_Less_32M },
            {   53, Type::Hidden_FAT16 },
            {   54, Type::Hidden_HPFS_or_NTFS },
            {   55, Type::AST_SmartSleep },
            {   56, Type::Hidden_Win95_FAT32 },
            {   57, Type::Hidden_Win95_FAT32_LBA },
            {   58, Type::Hidden_Win95_FAT16_LBA },
            {   59, Type::NEC_DOS },
            {   60, Type::Plan9 },
            {   61, Type::PartitionMagic_recovery },
            {   62, Type::Venix_80286 },
            {   63, Type::PPC_PReP_Boot },
            {   64, Type::SFS },
            {   65, Type::QNX4_dot_x },
            {   66, Type::QNX4_dot_x_2nd_part },
            {   67, Type::QNX4_dot_x_3rd_part },
            {   68, Type::OnTrack_DM },
            {   69, Type::OnTrack_DM6_Aux1 },
            {   70, Type::CP_M },
            {   71, Type::OnTrack_DM6_Aux3 },
            {   72, Type::OnTrackDM6 },
            {   73, Type::EZ_Drive },
            {   74, Type::Golden_Bow },
            {   75, Type::Priam_Edisk },
            {   76, Type::SpeedStor },
            {   77, Type::GNU_HURD_or_SysV },
            {   78, Type::Novell_Netware_286 },
            {   79, Type::Novell_Netware_386 },
            {   80, Type::DiskSecure_Multi_Boot },
            {   81, Type::PC_IX },
            {   82, Type::Old_Minix },
            {   83, Type::Minix_old_Linux },
            {   84, Type::Linux_swap },
            {   85, Type::Linux },
            {   86, Type::OS2_hidden_C_drive },
            {   87, Type::Linux_extended },
            {   88, Type::NTFS_volume_set_1 },
            {   89, Type::NTFS_volume_set_2 },
            {   90, Type::Linux_LVM },
            {   91, Type::Amoeba },
            {   92, Type::Amoeba_BBT },
            {   93, Type::BSD_OS },
            {   94, Type::IBM_Thinkpad_hibernation },
            {   95, Type::FreeBSD },
            {   96, Type::OpenBSD },
            {   97, Type::NeXTSTEP },
            {   98, Type::NetBSD },
            {   99, Type::BSDI_fs },
            {  100, Type::BSDI_swap },
            {  101, Type::Boot_Wizard_hidden },
            {  102, Type::DRDOS_sec_FAT12 },
            {  103, Type::DRDOS_sec_FAT16_Less_32M },
            {  104, Type::DRDOS_sec_FAT16 },
            {  105, Type::DRDOS_sec_extend },
            {  106, Type::Syrinx },
            {  107, Type::Non_FS_data },
            {  108, Type::Multiuser_DOS_extend },
            {  109, Type::CP_M_CTOS_dot_dot_dot },
            {  110, Type::Dell_Utility },
            {  111, Type::BootIt },
            {  112, Type::DOS_access },
            {  113, Type::DOS_R_O },
            {  114, Type::SpeedStor_1 },
            {  115, Type::BeOS_fs },
            {  116, Type::EFI_GPT },
            {  117, Type::EFI_FAT12_16_32 },
            {  118, Type::Linux_PA_RISC_boot },
            {  119, Type::SpeedStor_2 },
            {  120, Type::SeppdStor_3 },
            {  121, Type::DOS_secondary },
            {  122, Type::Linux_raid_autodetect },
            {  123, Type::LANstep },
            {  124, Type::BBT },
            {  125, Type::Unknow },
        }),
        // enum 'GUIDType'
        QtMocHelpers::EnumData<enum GUIDType>(33, 33, QMC::EnumFlags{}).add({
            {  126, GUIDType::InvalidUUID },
            {  127, GUIDType::GUIDTypeBegin },
            {  128, GUIDType::Unused_None },
            {  129, GUIDType::MBR_PS_None },
            {  130, GUIDType::EFI_SP_None },
            {  131, GUIDType::BIOS_BP_None },
            {  132, GUIDType::iFFS_None },
            {  133, GUIDType::Sony_BP_None },
            {  134, GUIDType::Lenove_BP_None },
            {  135, GUIDType::MSR_Win },
            {  136, GUIDType::BasicData_Win },
            {  137, GUIDType::LDM_Win },
            {  138, GUIDType::LDM_DP_Win },
            {  139, GUIDType::WRE_Win },
            {  140, GUIDType::IBM_GPFS_Win },
            {  141, GUIDType::SSP_Win },
            {  142, GUIDType::DP_HPUX },
            {  143, GUIDType::SP_HPUX },
            {  144, GUIDType::LFD_Linux },
            {  145, GUIDType::RAID_P_Linux },
            {  146, GUIDType::RP_x86_Linux },
            {  147, GUIDType::RP_x86_64_Linux },
            {  148, GUIDType::RP_32bit_ARM_Linux },
            {  149, GUIDType::RP_64bit_ARM_Linux },
            {  150, GUIDType::SP_Linux },
            {  151, GUIDType::LVM_P_Linux },
            {  152, GUIDType::Home_P_Linux },
            {  153, GUIDType::Srv_P_Linux },
            {  154, GUIDType::Plain_DC_P_Linux },
            {  155, GUIDType::LUKS_P_Linux },
            {  156, GUIDType::Reserved_Linux },
            {  157, GUIDType::BP_FreeBSD },
            {  158, GUIDType::DP_FreeBSD },
            {  159, GUIDType::SP_FreeBSD },
            {  160, GUIDType::UFS_P_FreeBSD },
            {  161, GUIDType::VVM_P_FreeBSD },
            {  162, GUIDType::ZFS_P_FreeBSD },
            {  163, GUIDType::HFS_PLUS_P_Mac },
            {  164, GUIDType::UFS_Mac },
            {  165, GUIDType::ZFS_Mac },
            {  166, GUIDType::RAID_P_Mac },
            {  167, GUIDType::RAID_P_Offline_Mac },
            {  168, GUIDType::BP_Mac },
            {  169, GUIDType::Label_Mac },
            {  170, GUIDType::TV_RP_Mac },
            {  171, GUIDType::CS_P_Mac },
            {  172, GUIDType::SoftRAID_Status_Mac },
            {  173, GUIDType::SoftRAID_Scratch_Mac },
            {  174, GUIDType::SoftRAID_Volume_Mac },
            {  175, GUIDType::SoftRAID_Cache_Mac },
            {  176, GUIDType::BP_Solaris },
            {  177, GUIDType::RP_Solaris },
            {  178, GUIDType::SP_Solaris },
            {  179, GUIDType::Backup_P_Solaris },
            {  180, GUIDType::Usr_P_Solaris },
            {  181, GUIDType::Var_P_Solaris },
            {  182, GUIDType::Home_P_Solaris },
            {  183, GUIDType::AS_Solaris },
            {  184, GUIDType::Reserved_Solaris },
            {  185, GUIDType::SP_NetBSD },
            {  186, GUIDType::FFS_P_NetBSD },
            {  187, GUIDType::LFS_P_NetBSD },
            {  188, GUIDType::RAID_P_NetBSD },
            {  189, GUIDType::CP_NetBSD },
            {  190, GUIDType::EP_NetBSD },
            {  191, GUIDType::Kernel_ChromeOS },
            {  192, GUIDType::Rootfs_ChromeOS },
            {  193, GUIDType::FU_ChromeOS },
            {  194, GUIDType::BFS_Haiku },
            {  195, GUIDType::BP_MidnightBSD },
            {  196, GUIDType::DP_MidnightBSD },
            {  197, GUIDType::SP_MidnightBSD },
            {  198, GUIDType::UFS_P_MidnightBSD },
            {  199, GUIDType::VVM_P_MidnightBSD },
            {  200, GUIDType::ZFS_P_MidnightBSD },
            {  201, GUIDType::Journal_Ceph },
            {  202, GUIDType::DC_EJ_Ceph },
            {  203, GUIDType::OSD_Ceph },
            {  204, GUIDType::DC_OSD_Ceph },
            {  205, GUIDType::DIC_Ceph },
            {  206, GUIDType::DC_DIC_Ceph },
            {  207, GUIDType::DP_OpenBSD },
            {  208, GUIDType::PAFS_QNX },
            {  209, GUIDType::Partition_Plan9 },
            {  210, GUIDType::Vmkcore_VMware },
            {  211, GUIDType::VMFS_VMware },
            {  212, GUIDType::Reserved_VMware },
            {  213, GUIDType::Bootloader_Android },
            {  214, GUIDType::Bottloader2_Android },
            {  215, GUIDType::Boot_Android },
            {  216, GUIDType::Recovery_Android },
            {  217, GUIDType::Misc_Android },
            {  218, GUIDType::Metadata_Android },
            {  219, GUIDType::System_Android },
            {  220, GUIDType::Cache_Android },
            {  221, GUIDType::Data_Android },
            {  222, GUIDType::Persistent_Android },
            {  223, GUIDType::Factory_Android },
            {  224, GUIDType::Fastboot_Android },
            {  225, GUIDType::OEM_Android },
            {  226, GUIDType::Boot_ONIE },
            {  227, GUIDType::Config_ONIE },
            {  228, GUIDType::Boot_PowerPC },
            {  229, GUIDType::SBLC_OSes },
            {  230, GUIDType::BD_P_Atari },
            {  231, GUIDType::GUIDTypeEnd },
            {  232, GUIDType::UnknowUUID },
        }),
    };
    return QtMocHelpers::metaObjectData<DBlockPartition, qt_meta_tag_ZN15DBlockPartitionE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DBlockPartition::staticMetaObject = { {
    QMetaObject::SuperData::link<DBlockDevice::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15DBlockPartitionE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15DBlockPartitionE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15DBlockPartitionE_t>.metaTypes,
    nullptr
} };

void DBlockPartition::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DBlockPartition *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->flagsChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 1: _t->isContainedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->isContainerChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->nameChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 4: _t->numberChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 5: _t->offsetChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 6: _t->sizeChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 7: _t->typeChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 8: _t->eTypeChanged(); break;
        case 9: _t->UUIDChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 10: _t->guidTypeChanged(); break;
        case 11: _t->deletePartition((*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[1]))); break;
        case 12: _t->resize((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[2]))); break;
        case 13: _t->setFlags((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[2]))); break;
        case 14: _t->setName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[2]))); break;
        case 15: _t->setType((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[2]))); break;
        case 16: _t->setType((*reinterpret_cast<std::add_pointer_t<enum Type>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DBlockPartition::*)(qulonglong )>(_a, &DBlockPartition::flagsChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DBlockPartition::*)(bool )>(_a, &DBlockPartition::isContainedChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DBlockPartition::*)(bool )>(_a, &DBlockPartition::isContainerChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (DBlockPartition::*)(const QString & )>(_a, &DBlockPartition::nameChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (DBlockPartition::*)(uint )>(_a, &DBlockPartition::numberChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (DBlockPartition::*)(qulonglong )>(_a, &DBlockPartition::offsetChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (DBlockPartition::*)(qulonglong )>(_a, &DBlockPartition::sizeChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (DBlockPartition::*)(const QString & )>(_a, &DBlockPartition::typeChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (DBlockPartition::*)()>(_a, &DBlockPartition::eTypeChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (DBlockPartition::*)(const QString & )>(_a, &DBlockPartition::UUIDChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (DBlockPartition::*)()>(_a, &DBlockPartition::guidTypeChanged, 10))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qulonglong*>(_v) = _t->flags(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->isContained(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->isContainer(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->name(); break;
        case 4: *reinterpret_cast<uint*>(_v) = _t->number(); break;
        case 5: *reinterpret_cast<qulonglong*>(_v) = _t->offset(); break;
        case 6: *reinterpret_cast<qulonglong*>(_v) = _t->size(); break;
        case 7: *reinterpret_cast<QString*>(_v) = _t->table(); break;
        case 8: *reinterpret_cast<QString*>(_v) = _t->type(); break;
        case 9: *reinterpret_cast<enum Type*>(_v) = _t->eType(); break;
        case 10: *reinterpret_cast<enum GUIDType*>(_v) = _t->guidType(); break;
        case 11: *reinterpret_cast<QString*>(_v) = _t->UUID(); break;
        default: break;
        }
    }
}

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

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

int DBlockPartition::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DBlockDevice::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 17)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 17;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 17)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 17;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 12;
    }
    return _id;
}

// SIGNAL 0
void DBlockPartition::flagsChanged(qulonglong _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

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

// SIGNAL 2
void DBlockPartition::isContainerChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void DBlockPartition::nameChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void DBlockPartition::numberChanged(uint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void DBlockPartition::offsetChanged(qulonglong _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void DBlockPartition::sizeChanged(qulonglong _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void DBlockPartition::typeChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void DBlockPartition::eTypeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void DBlockPartition::UUIDChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void DBlockPartition::guidTypeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}
QT_WARNING_POP
