#include "idescriptor_rust_codebase/src/service_manager.cxxqt.h"


// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust::cxxqt1 {
template <>
SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamscable_info_retrieved *>::~SignalHandler() noexcept
{
    if (data[0] == nullptr && data[1] == nullptr)
    {
        return;
    }

    drop_ServiceManager_signal_handler_cable_info_retrieved(::std::move(*this));
}

template <>
template <>
void SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamscable_info_retrieved *>::operator()<CXX::ServiceManager&, QString>(CXX::ServiceManager& self, QString info)
{
    call_ServiceManager_signal_handler_cable_info_retrieved(*this, self, ::std::move(info));
}

static_assert(alignof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamscable_info_retrieved *>) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamscable_info_retrieved *>) == sizeof(::std::size_t[2]), "unexpected size");
} // namespace rust::cxxqt1

namespace CXX::rust::cxxqtgen1 {
::QMetaObject::Connection
ServiceManager_cable_info_retrievedConnect(CXX::ServiceManager& self, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlercable_info_retrieved closure, ::Qt::ConnectionType type)
{
    return ::QObject::connect(
        &self,
        &CXX::ServiceManager::cable_info_retrieved,
        &self,
        [&, closure = ::std::move(closure)](QString info) mutable {
            closure.template operator()<CXX::ServiceManager&, QString>(self, ::std::move(info));
        },
        type);
}
} // namespace CXX::rust::cxxqtgen1

// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust::cxxqt1 {
template <>
SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsmobilegestalt_info_retrieved *>::~SignalHandler() noexcept
{
    if (data[0] == nullptr && data[1] == nullptr)
    {
        return;
    }

    drop_ServiceManager_signal_handler_mobilegestalt_info_retrieved(::std::move(*this));
}

template <>
template <>
void SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsmobilegestalt_info_retrieved *>::operator()<CXX::ServiceManager&, QMap_QString_QVariant>(CXX::ServiceManager& self, QMap_QString_QVariant info)
{
    call_ServiceManager_signal_handler_mobilegestalt_info_retrieved(*this, self, ::std::move(info));
}

static_assert(alignof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsmobilegestalt_info_retrieved *>) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsmobilegestalt_info_retrieved *>) == sizeof(::std::size_t[2]), "unexpected size");
} // namespace rust::cxxqt1

namespace CXX::rust::cxxqtgen1 {
::QMetaObject::Connection
ServiceManager_mobilegestalt_info_retrievedConnect(CXX::ServiceManager& self, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermobilegestalt_info_retrieved closure, ::Qt::ConnectionType type)
{
    return ::QObject::connect(
        &self,
        &CXX::ServiceManager::mobilegestalt_info_retrieved,
        &self,
        [&, closure = ::std::move(closure)](QMap_QString_QVariant info) mutable {
            closure.template operator()<CXX::ServiceManager&, QMap_QString_QVariant>(self, ::std::move(info));
        },
        type);
}
} // namespace CXX::rust::cxxqtgen1

// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust::cxxqt1 {
template <>
SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsdev_image_mounted *>::~SignalHandler() noexcept
{
    if (data[0] == nullptr && data[1] == nullptr)
    {
        return;
    }

    drop_ServiceManager_signal_handler_dev_image_mounted(::std::move(*this));
}

template <>
template <>
void SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsdev_image_mounted *>::operator()<CXX::ServiceManager&, bool, bool>(CXX::ServiceManager& self, bool success, bool is_locked)
{
    call_ServiceManager_signal_handler_dev_image_mounted(*this, self, ::std::move(success), ::std::move(is_locked));
}

static_assert(alignof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsdev_image_mounted *>) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsdev_image_mounted *>) == sizeof(::std::size_t[2]), "unexpected size");
} // namespace rust::cxxqt1

namespace CXX::rust::cxxqtgen1 {
::QMetaObject::Connection
ServiceManager_dev_image_mountedConnect(CXX::ServiceManager& self, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdev_image_mounted closure, ::Qt::ConnectionType type)
{
    return ::QObject::connect(
        &self,
        &CXX::ServiceManager::dev_image_mounted,
        &self,
        [&, closure = ::std::move(closure)](bool success, bool is_locked) mutable {
            closure.template operator()<CXX::ServiceManager&, bool, bool>(self, ::std::move(success), ::std::move(is_locked));
        },
        type);
}
} // namespace CXX::rust::cxxqtgen1

// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust::cxxqt1 {
template <>
SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsdeveloper_mode_option_revealed *>::~SignalHandler() noexcept
{
    if (data[0] == nullptr && data[1] == nullptr)
    {
        return;
    }

    drop_ServiceManager_signal_handler_developer_mode_option_revealed(::std::move(*this));
}

template <>
template <>
void SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsdeveloper_mode_option_revealed *>::operator()<CXX::ServiceManager&, bool>(CXX::ServiceManager& self, bool success)
{
    call_ServiceManager_signal_handler_developer_mode_option_revealed(*this, self, ::std::move(success));
}

static_assert(alignof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsdeveloper_mode_option_revealed *>) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsdeveloper_mode_option_revealed *>) == sizeof(::std::size_t[2]), "unexpected size");
} // namespace rust::cxxqt1

namespace CXX::rust::cxxqtgen1 {
::QMetaObject::Connection
ServiceManager_developer_mode_option_revealedConnect(CXX::ServiceManager& self, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdeveloper_mode_option_revealed closure, ::Qt::ConnectionType type)
{
    return ::QObject::connect(
        &self,
        &CXX::ServiceManager::developer_mode_option_revealed,
        &self,
        [&, closure = ::std::move(closure)](bool success) mutable {
            closure.template operator()<CXX::ServiceManager&, bool>(self, ::std::move(success));
        },
        type);
}
} // namespace CXX::rust::cxxqtgen1

// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust::cxxqt1 {
template <>
SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsmounted_image_retrieved *>::~SignalHandler() noexcept
{
    if (data[0] == nullptr && data[1] == nullptr)
    {
        return;
    }

    drop_ServiceManager_signal_handler_mounted_image_retrieved(::std::move(*this));
}

template <>
template <>
void SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsmounted_image_retrieved *>::operator()<CXX::ServiceManager&, bool, bool, QByteArray, ::std::uint64_t>(CXX::ServiceManager& self, bool success, bool is_locked, QByteArray sig, ::std::uint64_t sig_length)
{
    call_ServiceManager_signal_handler_mounted_image_retrieved(*this, self, ::std::move(success), ::std::move(is_locked), ::std::move(sig), ::std::move(sig_length));
}

static_assert(alignof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsmounted_image_retrieved *>) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsmounted_image_retrieved *>) == sizeof(::std::size_t[2]), "unexpected size");
} // namespace rust::cxxqt1

namespace CXX::rust::cxxqtgen1 {
::QMetaObject::Connection
ServiceManager_mounted_image_retrievedConnect(CXX::ServiceManager& self, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlermounted_image_retrieved closure, ::Qt::ConnectionType type)
{
    return ::QObject::connect(
        &self,
        &CXX::ServiceManager::mounted_image_retrieved,
        &self,
        [&, closure = ::std::move(closure)](bool success, bool is_locked, QByteArray sig, ::std::uint64_t sig_length) mutable {
            closure.template operator()<CXX::ServiceManager&, bool, bool, QByteArray, ::std::uint64_t>(self, ::std::move(success), ::std::move(is_locked), ::std::move(sig), ::std::move(sig_length));
        },
        type);
}
} // namespace CXX::rust::cxxqtgen1

// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust::cxxqt1 {
template <>
SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsinstalled_apps_retrieved *>::~SignalHandler() noexcept
{
    if (data[0] == nullptr && data[1] == nullptr)
    {
        return;
    }

    drop_ServiceManager_signal_handler_installed_apps_retrieved(::std::move(*this));
}

template <>
template <>
void SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsinstalled_apps_retrieved *>::operator()<CXX::ServiceManager&, QMap_QString_QVariant const&>(CXX::ServiceManager& self, QMap_QString_QVariant const& apps)
{
    call_ServiceManager_signal_handler_installed_apps_retrieved(*this, self, ::std::move(apps));
}

static_assert(alignof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsinstalled_apps_retrieved *>) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsinstalled_apps_retrieved *>) == sizeof(::std::size_t[2]), "unexpected size");
} // namespace rust::cxxqt1

namespace CXX::rust::cxxqtgen1 {
::QMetaObject::Connection
ServiceManager_installed_apps_retrievedConnect(CXX::ServiceManager& self, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstalled_apps_retrieved closure, ::Qt::ConnectionType type)
{
    return ::QObject::connect(
        &self,
        &CXX::ServiceManager::installed_apps_retrieved,
        &self,
        [&, closure = ::std::move(closure)](QMap_QString_QVariant const& apps) mutable {
            closure.template operator()<CXX::ServiceManager&, QMap_QString_QVariant const&>(self, ::std::move(apps));
        },
        type);
}
} // namespace CXX::rust::cxxqtgen1

// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust::cxxqt1 {
template <>
SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsapp_icon_loaded *>::~SignalHandler() noexcept
{
    if (data[0] == nullptr && data[1] == nullptr)
    {
        return;
    }

    drop_ServiceManager_signal_handler_app_icon_loaded(::std::move(*this));
}

template <>
template <>
void SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsapp_icon_loaded *>::operator()<CXX::ServiceManager&, QString, QByteArray>(CXX::ServiceManager& self, QString bundle_id, QByteArray icon_data)
{
    call_ServiceManager_signal_handler_app_icon_loaded(*this, self, ::std::move(bundle_id), ::std::move(icon_data));
}

static_assert(alignof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsapp_icon_loaded *>) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsapp_icon_loaded *>) == sizeof(::std::size_t[2]), "unexpected size");
} // namespace rust::cxxqt1

namespace CXX::rust::cxxqtgen1 {
::QMetaObject::Connection
ServiceManager_app_icon_loadedConnect(CXX::ServiceManager& self, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerapp_icon_loaded closure, ::Qt::ConnectionType type)
{
    return ::QObject::connect(
        &self,
        &CXX::ServiceManager::app_icon_loaded,
        &self,
        [&, closure = ::std::move(closure)](QString bundle_id, QByteArray icon_data) mutable {
            closure.template operator()<CXX::ServiceManager&, QString, QByteArray>(self, ::std::move(bundle_id), ::std::move(icon_data));
        },
        type);
}
} // namespace CXX::rust::cxxqtgen1

// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust::cxxqt1 {
template <>
SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsbattery_info_updated *>::~SignalHandler() noexcept
{
    if (data[0] == nullptr && data[1] == nullptr)
    {
        return;
    }

    drop_ServiceManager_signal_handler_battery_info_updated(::std::move(*this));
}

template <>
template <>
void SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsbattery_info_updated *>::operator()<CXX::ServiceManager&, QString const&>(CXX::ServiceManager& self, QString const& info)
{
    call_ServiceManager_signal_handler_battery_info_updated(*this, self, ::std::move(info));
}

static_assert(alignof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsbattery_info_updated *>) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsbattery_info_updated *>) == sizeof(::std::size_t[2]), "unexpected size");
} // namespace rust::cxxqt1

namespace CXX::rust::cxxqtgen1 {
::QMetaObject::Connection
ServiceManager_battery_info_updatedConnect(CXX::ServiceManager& self, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerbattery_info_updated closure, ::Qt::ConnectionType type)
{
    return ::QObject::connect(
        &self,
        &CXX::ServiceManager::battery_info_updated,
        &self,
        [&, closure = ::std::move(closure)](QString const& info) mutable {
            closure.template operator()<CXX::ServiceManager&, QString const&>(self, ::std::move(info));
        },
        type);
}
} // namespace CXX::rust::cxxqtgen1

// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust::cxxqt1 {
template <>
SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsdisk_usage_retrieved *>::~SignalHandler() noexcept
{
    if (data[0] == nullptr && data[1] == nullptr)
    {
        return;
    }

    drop_ServiceManager_signal_handler_disk_usage_retrieved(::std::move(*this));
}

template <>
template <>
void SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsdisk_usage_retrieved *>::operator()<CXX::ServiceManager&, bool, ::std::uint64_t, ::std::uint64_t>(CXX::ServiceManager& self, bool success, ::std::uint64_t apps_usage, ::std::uint64_t gallery_usage)
{
    call_ServiceManager_signal_handler_disk_usage_retrieved(*this, self, ::std::move(success), ::std::move(apps_usage), ::std::move(gallery_usage));
}

static_assert(alignof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsdisk_usage_retrieved *>) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsdisk_usage_retrieved *>) == sizeof(::std::size_t[2]), "unexpected size");
} // namespace rust::cxxqt1

namespace CXX::rust::cxxqtgen1 {
::QMetaObject::Connection
ServiceManager_disk_usage_retrievedConnect(CXX::ServiceManager& self, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerdisk_usage_retrieved closure, ::Qt::ConnectionType type)
{
    return ::QObject::connect(
        &self,
        &CXX::ServiceManager::disk_usage_retrieved,
        &self,
        [&, closure = ::std::move(closure)](bool success, ::std::uint64_t apps_usage, ::std::uint64_t gallery_usage) mutable {
            closure.template operator()<CXX::ServiceManager&, bool, ::std::uint64_t, ::std::uint64_t>(self, ::std::move(success), ::std::move(apps_usage), ::std::move(gallery_usage));
        },
        type);
}
} // namespace CXX::rust::cxxqtgen1

// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust::cxxqt1 {
template <>
SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsinstall_ipa_init *>::~SignalHandler() noexcept
{
    if (data[0] == nullptr && data[1] == nullptr)
    {
        return;
    }

    drop_ServiceManager_signal_handler_install_ipa_init(::std::move(*this));
}

template <>
template <>
void SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsinstall_ipa_init *>::operator()<CXX::ServiceManager&, bool, QString>(CXX::ServiceManager& self, bool started, QString state)
{
    call_ServiceManager_signal_handler_install_ipa_init(*this, self, ::std::move(started), ::std::move(state));
}

static_assert(alignof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsinstall_ipa_init *>) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsinstall_ipa_init *>) == sizeof(::std::size_t[2]), "unexpected size");
} // namespace rust::cxxqt1

namespace CXX::rust::cxxqtgen1 {
::QMetaObject::Connection
ServiceManager_install_ipa_initConnect(CXX::ServiceManager& self, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_init closure, ::Qt::ConnectionType type)
{
    return ::QObject::connect(
        &self,
        &CXX::ServiceManager::install_ipa_init,
        &self,
        [&, closure = ::std::move(closure)](bool started, QString state) mutable {
            closure.template operator()<CXX::ServiceManager&, bool, QString>(self, ::std::move(started), ::std::move(state));
        },
        type);
}
} // namespace CXX::rust::cxxqtgen1

// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust::cxxqt1 {
template <>
SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsinstall_ipa_progress *>::~SignalHandler() noexcept
{
    if (data[0] == nullptr && data[1] == nullptr)
    {
        return;
    }

    drop_ServiceManager_signal_handler_install_ipa_progress(::std::move(*this));
}

template <>
template <>
void SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsinstall_ipa_progress *>::operator()<CXX::ServiceManager&, double, QString>(CXX::ServiceManager& self, double progress, QString state)
{
    call_ServiceManager_signal_handler_install_ipa_progress(*this, self, ::std::move(progress), ::std::move(state));
}

static_assert(alignof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsinstall_ipa_progress *>) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsinstall_ipa_progress *>) == sizeof(::std::size_t[2]), "unexpected size");
} // namespace rust::cxxqt1

namespace CXX::rust::cxxqtgen1 {
::QMetaObject::Connection
ServiceManager_install_ipa_progressConnect(CXX::ServiceManager& self, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerinstall_ipa_progress closure, ::Qt::ConnectionType type)
{
    return ::QObject::connect(
        &self,
        &CXX::ServiceManager::install_ipa_progress,
        &self,
        [&, closure = ::std::move(closure)](double progress, QString state) mutable {
            closure.template operator()<CXX::ServiceManager&, double, QString>(self, ::std::move(progress), ::std::move(state));
        },
        type);
}
} // namespace CXX::rust::cxxqtgen1

// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust::cxxqt1 {
template <>
SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsenable_wifi_connections_result *>::~SignalHandler() noexcept
{
    if (data[0] == nullptr && data[1] == nullptr)
    {
        return;
    }

    drop_ServiceManager_signal_handler_enable_wifi_connections_result(::std::move(*this));
}

template <>
template <>
void SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsenable_wifi_connections_result *>::operator()<CXX::ServiceManager&, bool>(CXX::ServiceManager& self, bool success)
{
    call_ServiceManager_signal_handler_enable_wifi_connections_result(*this, self, ::std::move(success));
}

static_assert(alignof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsenable_wifi_connections_result *>) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(SignalHandler<::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalParamsenable_wifi_connections_result *>) == sizeof(::std::size_t[2]), "unexpected size");
} // namespace rust::cxxqt1

namespace CXX::rust::cxxqtgen1 {
::QMetaObject::Connection
ServiceManager_enable_wifi_connections_resultConnect(CXX::ServiceManager& self, ::CXX::rust::cxxqtgen1::ServiceManagerCxxQtSignalHandlerenable_wifi_connections_result closure, ::Qt::ConnectionType type)
{
    return ::QObject::connect(
        &self,
        &CXX::ServiceManager::enable_wifi_connections_result,
        &self,
        [&, closure = ::std::move(closure)](bool success) mutable {
            closure.template operator()<CXX::ServiceManager&, bool>(self, ::std::move(success));
        },
        type);
}
} // namespace CXX::rust::cxxqtgen1

namespace CXX {
static_assert(alignof(ServiceManagerCxxQtThread) <= alignof(::std::size_t), "unexpected aligment");
static_assert(sizeof(ServiceManagerCxxQtThread) == sizeof(::std::size_t[2]), "unexpected size");

ServiceManager::ServiceManager(QString arg0, ::std::uint32_t arg1)
  : ServiceManager(::CXX::cxx_qt_ServiceManager::routeArguments0(::std::move(arg0), ::std::move(arg1)))
{ }

ServiceManager::ServiceManager(::CXX::cxx_qt_ServiceManager::CxxQtConstructorArguments0&& args)
  : QObject()
  , ::rust::cxxqt1::CxxQtType<RServiceManager>(::CXX::cxx_qt_ServiceManager::newRs0(::std::move(args.new_)))
  , ::rust::cxxqt1::CxxQtThreading<ServiceManager>(this)
{
  ::CXX::cxx_qt_ServiceManager::initialize0(*this, ::std::move(args.initialize));
}

} // namespace CXX

